<Self>(): <const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>) => Hyperlink.HyperlinkTag<Self, InstanceSpec<I, A, E>, Gate<PrettifyPayload<I['Type']>, Schema.Schema<out T>.Type<A>, Schema.Schema.Type<E>, never>> & { readonly run: StaticRun<I, A, E, Self>; } & { defaultSpec: { error: E; payload: I; success: A; effect: ServiceEffect<I, A, E, R>; concurrency?: number; rateLimit?: RateLimitOptions; name: Name; }; configure: (patch: ConfigPatch<LayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>>) => Layer.Layer<never, never, never>; wrapGate: (fn: (previous: LayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>['effect']) => LayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>['effect']) => Layer.Layer<never, never, never>; layer: Layer.Layer<Store.Storage | Self | Hyperlink.Local<Self>, never, R>; }Class factory: tag + wire schemas + baked-in .layer + .configure.
constructors
Source src/Gate.ts:103864 lines
export const const Service: <Self>() => <
Name extends string,
I extends Schema.Top = Schema.Void,
A extends Schema.Top = Schema.Void,
E extends Schema.Top = Schema.Never,
R = never
>(
name: Name,
config: ServiceConfig<I, A, E, R>
) => Hyperlink.HyperlinkTag<
Self,
InstanceSpec<I, A, E>,
Gate<
PrettifyPayload<I["Type"]>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
never
>
> & { readonly run: StaticRun<I, A, E, Self> } & {
defaultSpec: {
error: E
payload: I
success: A
effect: ServiceEffect<I, A, E, R>
concurrency?: number
rateLimit?: RateLimitOptions
name: Name
}
configure: (
patch: ConfigPatch<
LayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>
>
) => Layer.Layer<never, never, never>
wrapGate: (
fn: (
previous: LayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>["effect"]
) => LayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>["effect"]
) => Layer.Layer<never, never, never>
layer: Layer.Layer<
Self | Store.Storage | Hyperlink.Local<Self>,
never,
R
>
}
Class factory: tag + wire schemas + baked-in .layer + .configure.
Service = <function (type parameter) Self in <Self>(): <const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>) => Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
function (local function) build<Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<I, A, E>, Gate<PrettifyPayload<I['Type']>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, never>> & { readonly run: StaticRun<I, A, E, Self> } & { defaultSpec: { error: E; payload: I; success: A; effect: ServiceEffect<I, A, E, R>; concurrency?: number; rateLimit?: RateLimitOptions; name: Name }; configure: (patch: ConfigPatch<LayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>>) => Layer.Layer<never, never, never>; wrapGate: (fn: (previous: LayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>['effect']) => LayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>['effect']) => Layer.Layer<never, never, never>; layer: Layer.Layer<Self | Store.Storage | Hyperlink.Local<Self>, never, R> }build<
const function (type parameter) Name in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
function (type parameter) I in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
import SchemaSchema.Top = typeof import SchemaSchema.const Void: Voidconst Void: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<void, readonly []>) => Schema.Void;
annotateKey: (annotations: Schema.Annotations.Key<void>) => Schema.Void;
check: (checks_0: Check<void>, ...checks: Array<Check<void>>) => Schema.Void;
rebuild: (ast: Void) => Schema.Void;
make: (input: void, options?: MakeOptions) => void;
makeOption: (input: void, options?: MakeOptions) => Option_.Option<void>;
makeEffect: (input: void, options?: MakeOptions) => Effect.Effect<void, SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
Type-level representation of
Void
.
Schema for a TypeScript void return value.
When to use
Use when you need to model the return value of a function, RPC, or endpoint
whose result is intentionally ignored.
Details
Runtime parsing accepts any present value and discards it, producing
undefined. The public decoded and encoded TypeScript representation remains
void, so typed construction, decoding, and encoding APIs are still modeled
as void.
Void,
function (type parameter) A in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
import SchemaSchema.Top = typeof import SchemaSchema.const Void: Voidconst Void: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<void, readonly []>) => Schema.Void;
annotateKey: (annotations: Schema.Annotations.Key<void>) => Schema.Void;
check: (checks_0: Check<void>, ...checks: Array<Check<void>>) => Schema.Void;
rebuild: (ast: Void) => Schema.Void;
make: (input: void, options?: MakeOptions) => void;
makeOption: (input: void, options?: MakeOptions) => Option_.Option<void>;
makeEffect: (input: void, options?: MakeOptions) => Effect.Effect<void, SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
Type-level representation of
Void
.
Schema for a TypeScript void return value.
When to use
Use when you need to model the return value of a function, RPC, or endpoint
whose result is intentionally ignored.
Details
Runtime parsing accepts any present value and discards it, producing
undefined. The public decoded and encoded TypeScript representation remains
void, so typed construction, decoding, and encoding APIs are still modeled
as void.
Void,
function (type parameter) E in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
import SchemaSchema.Top = typeof import SchemaSchema.const Never: Neverconst Never: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<never, readonly []>) => Schema.Never;
annotateKey: (annotations: Schema.Annotations.Key<never>) => Schema.Never;
check: (checks_0: Check<never>, ...checks: Array<Check<never>>) => Schema.Never;
rebuild: (ast: Never) => Schema.Never;
make: (input: never, options?: MakeOptions) => never;
makeOption: (input: never, options?: MakeOptions) => Option_.Option<never>;
makeEffect: (input: never, options?: MakeOptions) => Effect.Effect<never, SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
Type-level representation of
Never
.
Schema for the never type. Always fails validation — no value satisfies it.
Never,
function (type parameter) R in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
name: const Name extends stringname: function (type parameter) Name in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
config: ServiceConfig<I, A, E, R>(parameter) config: {
effect: ServiceEffect<I, A, E, R>;
concurrency: number;
rateLimit: RateLimitOptions;
payload: I;
success: A;
error: E;
}
interface ServiceConfig<I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>Full
Service
config — wire schemas and the gated effect in one object.
ServiceConfig<function (type parameter) I in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
function (type parameter) A in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
function (type parameter) E in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
function (type parameter) R in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
const wire: {
readonly payload: I
readonly success: A
readonly error: E
}
const resolveRunWireSchemas: <
I extends Schema.Top,
A extends Schema.Top,
E extends Schema.Top
>(
config: WireSchemas<I, A, E>
) => {
readonly payload: I
readonly success: A
readonly error: E
}
Resolved wire schemas with RPC defaults applied.
resolveRunWireSchemas(config: ServiceConfig<I, A, E, R>(parameter) config: {
effect: ServiceEffect<I, A, E, R>;
concurrency: number;
rateLimit: RateLimitOptions;
payload: I;
success: A;
error: E;
}
const tag: GateTagWithStaticRun<
Self,
I,
A,
E
>
const runTag: <Self>() => {
(key: string): GateTagWithStaticRun<
Self,
typeof Schema.Void,
typeof Schema.Void,
typeof Schema.Never
>
<
I extends Schema.Top,
A extends Schema.Top,
E extends Schema.Top,
D extends Hyperlink.DefaultsBag
>(
key: string,
config: TagSchemas<I, A, E> & {
readonly defaults: Hyperlink.DefaultsInput<D>
}
): Hyperlink.TagWithDefaults<
GateTagWithStaticRun<Self, I, A, E>,
D
>
<
I extends Schema.Top,
A extends Schema.Top,
E extends Schema.Top = Schema.Never
>(
key: string,
config: TagSchemas<I, A, E>
): GateTagWithStaticRun<Self, I, A, E>
<
I extends Schema.Top,
A extends Schema.Top,
D extends Hyperlink.DefaultsBag
>(
key: string,
payload: I,
success: A,
options: {
readonly description?: string
readonly defaults: Hyperlink.DefaultsInput<D>
}
): Hyperlink.TagWithDefaults<
GateTagWithStaticRun<
Self,
I,
A,
typeof Schema.Never
>,
D
>
<I extends Schema.Top, A extends Schema.Top>(
key: string,
payload: I,
success: A,
options?: GateTagPositionalOptions
): GateTagWithStaticRun<
Self,
I,
A,
typeof Schema.Never
>
<
I extends Schema.Top,
A extends Schema.Top,
E extends Schema.Top,
D extends Hyperlink.DefaultsBag
>(
key: string,
payload: I,
success: A,
error: E,
options: {
readonly description?: string
readonly defaults: Hyperlink.DefaultsInput<D>
}
): Hyperlink.TagWithDefaults<
GateTagWithStaticRun<Self, I, A, E>,
D
>
<
I extends Schema.Top,
A extends Schema.Top,
E extends Schema.Top
>(
key: string,
payload: I,
success: A,
error: E,
options?: GateTagPositionalOptions
): GateTagWithStaticRun<Self, I, A, E>
}
function (type parameter) Self in <Self>(): <const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>) => Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
name: const Name extends stringname, {
...config: ServiceConfig<I, A, E, R>(parameter) config: {
effect: ServiceEffect<I, A, E, R>;
concurrency: number;
rateLimit: RateLimitOptions;
payload: I;
success: A;
error: E;
}
TagSchemas<I extends Schema.Top = Top, A extends Schema.Top = Top, E extends Schema.Top = Never>.rateLimit?: internal.GateRateLimitOptions | undefinedOptional rate-limit policy declaration on the Tag — stamps rateLimitKey
metadata for widgets. Engine still needs rateLimit on
layer
/
Service
config to enforce.
rateLimit: config: ServiceConfig<I, A, E, R>(parameter) config: {
effect: ServiceEffect<I, A, E, R>;
concurrency: number;
rateLimit: RateLimitOptions;
payload: I;
success: A;
error: E;
}
ServiceConfig<I, A, E, R>.rateLimit?: RateLimitOptionsOptional Effect RateLimiter on each run (before the concurrency semaphore).
Omitted = no rate limit (only
concurrency
).
rateLimit,
});
const const error: E extends Schema.Top = Schema.Nevererror = const wire: {
readonly payload: I
readonly success: A
readonly error: E
}
error: E extends Schema.Top = Schema.Nevererror;
const const defaultSpec: {
error: E
payload: I
success: A
effect: ServiceEffect<I, A, E, R>
concurrency?: number
rateLimit?: RateLimitOptions
name: Name
}
name: const Name extends stringname, ...config: ServiceConfig<I, A, E, R>(parameter) config: {
effect: ServiceEffect<I, A, E, R>;
concurrency: number;
rateLimit: RateLimitOptions;
payload: I;
success: A;
error: E;
}
const wire: {
readonly payload: I
readonly success: A
readonly error: E
}
error: E extends Schema.Top = Schema.Nevererror };
const const layerConfig: LayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>
const layerConfig: {
name: string;
effect: LayerEffect<I, A, E, R>;
concurrency: number;
rateLimit: RateLimitOptions;
}
interface LayerConfig<I, A, E, R>Layer / serve config — the tag carries wire schemas; this supplies the gated effect.
LayerConfig<
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) I in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) A in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) E in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
function (type parameter) R in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
LayerConfig<Schema<out T>.Type<I>, Schema.Type<A>, Schema.Type<E>, R>.effect: ServiceEffect<I, A, E, R>Unit gates may pass a bare effect; parameterized gates use (input) => Effect.
effect: config: ServiceConfig<I, A, E, R>(parameter) config: {
effect: ServiceEffect<I, A, E, R>;
concurrency: number;
rateLimit: RateLimitOptions;
payload: I;
success: A;
error: E;
}
ServiceConfig<I, A, E, R>.effect: ServiceEffect<I, A, E, R>Unit gates may pass a bare effect; parameterized gates use (input) => Effect.
effect,
LayerConfig<Schema<out T>.Type<I>, Schema.Type<A>, Schema.Type<E>, R>.concurrency?: number | undefinedMax concurrent executions through this gate.
concurrency: config: ServiceConfig<I, A, E, R>(parameter) config: {
effect: ServiceEffect<I, A, E, R>;
concurrency: number;
rateLimit: RateLimitOptions;
payload: I;
success: A;
error: E;
}
ServiceConfig<I, A, E, R>.concurrency?: number | undefinedMax concurrent executions through this gate.
concurrency,
LayerConfig<Schema<out T>.Type<I>, Schema.Type<A>, Schema.Type<E>, R>.rateLimit?: internal.GateRateLimitOptions | undefinedOptional Effect RateLimiter on each run (before the concurrency semaphore).
Omitted = no rate limit (only
concurrency
).
rateLimit: config: ServiceConfig<I, A, E, R>(parameter) config: {
effect: ServiceEffect<I, A, E, R>;
concurrency: number;
rateLimit: RateLimitOptions;
payload: I;
success: A;
error: E;
}
ServiceConfig<I, A, E, R>.rateLimit?: RateLimitOptionsOptional Effect RateLimiter on each run (before the concurrency semaphore).
Omitted = no rate limit (only
concurrency
).
rateLimit,
LayerConfig<Schema<out T>.Type<I>, Schema.Type<A>, Schema.Type<E>, R>.name?: string | undefinedOverride telemetry / status resourceId; defaults to the tag key.
name,
};
return var Object: ObjectConstructorProvides functionality common to all JavaScript objects.
Object.ObjectConstructor.assign<GateTagWithStaticRun<Self, I, A, E>, {
defaultSpec: {
error: E;
payload: I;
success: A;
effect: ServiceEffect<I, A, E, R>;
concurrency?: number;
rateLimit?: RateLimitOptions;
name: Name;
};
configure: (patch: ConfigPatch<LayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>>) => Layer.Layer<never, never, never>;
wrapGate: (fn: (previous: LayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>["effect"]) => LayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>["effect"]) => Layer.Layer<...>;
layer: Layer.Layer<...>;
}>(target: GateTagWithStaticRun<...>, source: {
defaultSpec: {
error: E;
payload: I;
success: A;
effect: ServiceEffect<I, A, E, R>;
concurrency?: number;
rateLimit?: RateLimitOptions;
name: Name;
};
configure: (patch: ConfigPatch<LayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>>) => Layer.Layer<never, never, never>;
wrapGate: (fn: (previous: LayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>["effect"]) => LayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>["effect"]) => Layer.Layer<...>;
layer: Layer.Layer<...>;
}): Hyperlink.HyperlinkTag<...> & ... 1 more ... & {
defaultSpec: {
error: E;
payload: I;
success: A;
effect: ServiceEffect<I, A, E, R>;
concurrency?: number;
rateLimit?: RateLimitOptions;
name: Name;
};
configure: (patch: ConfigPatch<LayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>>) => Layer.Layer<never, never, never>;
wrapGate: (fn: (previous: LayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>["effect"]) => LayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>["effect"]) => Layer.Layer<...>;
layer: Layer.Layer<...>;
} (+3 overloads)
Copy the values of all of the enumerable own properties from one or more source objects to a
target object. Returns the target object.
assign(const tag: GateTagWithStaticRun<
Self,
I,
A,
E
>
defaultSpec: {
error: E
payload: I
success: A
effect: ServiceEffect<I, A, E, R>
concurrency?: number
rateLimit?: RateLimitOptions
name: Name
}
configure: (
patch: ConfigPatch<
LayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>
>
) => Layer.Layer<never, never, never>
patch: ConfigPatch<
LayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>
>
type ConfigPatch<T> = PartialConfigPatch<T> | ((previous: T) => T)Patch for a hyperlink or daemon spec.
- Partial object — shallow-merge fields; use a function value to replace a field.
effect field — a unary function (previous) => next updates the prior worker /
supervised body; a multi-argument function value replaces effect outright (queue workers
stay two-argument).- Full reducer —
(previous) => next over the whole spec (see
configureLayer
).
ConfigPatch<
interface LayerConfig<I, A, E, R>Layer / serve config — the tag carries wire schemas; this supplies the gated effect.
LayerConfig<
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) I in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) A in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) E in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
function (type parameter) R in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
configureLayer<T extends object>(resourceId: string, patch: ConfigPatch<T>): Layer.Layer<never>Layer that appends one configure patch for resourceId.
Provide or merge with the HyperService .layer so patches are visible when that layer builds.
configureLayer(name: const Name extends stringname, patch: ConfigPatch<
LayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>
>
wrapGate: (
fn: (
previous: LayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>["effect"]
) => LayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>["effect"]
) => Layer.Layer<never, never, never>
fn: (
previous: LayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>["effect"]
) => LayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>["effect"]
previous: LayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>["effect"]
interface LayerConfig<I, A, E, R>Layer / serve config — the tag carries wire schemas; this supplies the gated effect.
LayerConfig<
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) I in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) A in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) E in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
function (type parameter) R in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
interface LayerConfig<I, A, E, R>Layer / serve config — the tag carries wire schemas; this supplies the gated effect.
LayerConfig<
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) I in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) A in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) E in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
function (type parameter) R in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<...>, Gate<...>> & {
...;
} & {
...;
}
configureWrapEffectField<T extends { readonly effect: F }, F>(resourceId: string, fn: (previous: F) => F): Layer.Layer<never>configureLayer
that replaces only effect via fn(previous).
configureWrapEffectField(name: const Name extends stringname, fn: (
previous: LayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>["effect"]
) => LayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>["effect"]
layer: Layer.Layer<
Self | Store.Storage | Hyperlink.Local<Self>,
never,
R
>
(property) layer: {
build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<Context.Context<Self | Storage | Local<Self>>, never, R>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
const layer: <
Self,
I extends Schema.Top,
A extends Schema.Top,
E extends Schema.Top = Schema.Never,
R = never
>(
tag: HyperlinkTag<
Self,
InstanceSpec<I, A, E>,
any
>,
config: LayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>
) => Layer.Layer<
Self | Local<Self> | Store.Storage,
never,
R
>
Build a Layer from a tag and config — yields an observable toolkit service.
Soft-defaults
Store.Storage
(R fulfilled). Override with your app store:
Gate.layer(Tag, config).pipe(Layer.provideMerge(AppStore.layer({ filename })))
layerMemory
is an alias for the same soft-default.
layer(const tag: GateTagWithStaticRun<
Self,
I,
A,
E
>
const layerConfig: LayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>
const layerConfig: {
name: string;
effect: LayerEffect<I, A, E, R>;
concurrency: number;
rateLimit: RateLimitOptions;
}
function (local function) build<Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: ServiceConfig<I, A, E, R>): Hyperlink.HyperlinkTag<Self, InstanceSpec<I, A, E>, Gate<PrettifyPayload<I['Type']>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, never>> & { readonly run: StaticRun<I, A, E, Self> } & { defaultSpec: { error: E; payload: I; success: A; effect: ServiceEffect<I, A, E, R>; concurrency?: number; rateLimit?: RateLimitOptions; name: Name }; configure: (patch: ConfigPatch<LayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>>) => Layer.Layer<never, never, never>; wrapGate: (fn: (previous: LayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>['effect']) => LayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>['effect']) => Layer.Layer<never, never, never>; layer: Layer.Layer<Self | Store.Storage | Hyperlink.Local<Self>, never, R> }build;
};