brickflow 0.0.1 → 0.0.2

package/dist/index.d.ts

@@ -0,0 +1,496 @@
+import { P } from 'ts-pattern';
+export { P } from 'ts-pattern';
+
+interface SignalDefinition<Request = unknown, Response = unknown> {
+    readonly request: Request;
+    readonly response: Response;
+}
+type SignalDefinitions = Readonly<Record<string, SignalDefinition>>;
+type SignalRequest<Definition> = Definition extends SignalDefinition<infer Request, unknown> ? Request : never;
+type SignalResponse<Definition> = Definition extends SignalDefinition<unknown, infer Response> ? Response : never;
+type ValidSignalDefinition<Definition extends SignalDefinition> = undefined extends SignalResponse<Definition> ? never : Definition;
+type SignalFunction<Definition extends SignalDefinition> = Definition extends ValidSignalDefinition<Definition> ? (request: SignalRequest<Definition>) => Promise<SignalResponse<Definition>> : never;
+type SignalFunctions<Definitions extends SignalDefinitions> = {
+    readonly [Name in keyof Definitions]: SignalFunction<Definitions[Name]>;
+};
+type InternalSignalHandler<Definition extends SignalDefinition> = (request: SignalRequest<Definition>) => SignalResponse<Definition> | undefined | Promise<SignalResponse<Definition> | undefined>;
+type BoundarySignalHandler<Definition extends SignalDefinition> = (request: SignalRequest<Definition>) => SignalResponse<Definition> | Promise<SignalResponse<Definition>>;
+type InternalSignalHandlers<Definitions extends SignalDefinitions> = {
+    readonly [Name in keyof Definitions]?: InternalSignalHandler<Definitions[Name]>;
+};
+type BoundarySignalHandlers<Definitions extends SignalDefinitions> = {
+    readonly [Name in keyof Definitions]-?: BoundarySignalHandler<Definitions[Name]>;
+};
+type UnknownSignalHandler = (request: unknown) => unknown | Promise<unknown>;
+type UnknownSignalHandlers = Readonly<Record<string, UnknownSignalHandler | undefined>>;
+interface SignalHandlerChain {
+    readonly handlers: UnknownSignalHandlers;
+    readonly parent?: SignalHandlerChain;
+    readonly boundary: boolean;
+}
+interface SignalCallMetadata {
+    readonly durableName: string;
+    readonly signalName: string;
+    readonly layerPath: readonly string[];
+    readonly brickPath: readonly string[];
+    readonly callId: string;
+    readonly occurrence: number;
+}
+
+type ValidPathSegment<Value extends string> = Value extends '' ? never : Value extends `${string}.${string}` ? never : Value;
+type ValidatePathSegmentKeys<Values extends object> = {
+    readonly [Key in keyof Values]: Key extends string ? ValidPathSegment<Key> extends never ? never : Values[Key] : never;
+};
+type HasValidPathSegmentKeys<Values extends object> = Values extends ValidatePathSegmentKeys<Values> ? true : false;
+
+interface ExecutionContextOptions {
+    readonly layerPath?: readonly string[];
+    readonly brickPath?: readonly string[];
+    readonly callId: string;
+    readonly providers?: Readonly<Record<string, unknown>>;
+    readonly signalHandlers?: SignalHandlerChain;
+}
+declare class ExecutionContext {
+    #private;
+    readonly layerPath: readonly string[];
+    readonly brickPath: readonly string[];
+    readonly callId: string;
+    readonly providers: Readonly<Record<string, unknown>>;
+    readonly signalHandlers: SignalHandlerChain | undefined;
+    constructor(options: ExecutionContextOptions);
+    childLayer(segment: string): ExecutionContext;
+    childBrick(segment: string, callId: string): ExecutionContext;
+    withSignalHandlers(signalHandlers: SignalHandlerChain): ExecutionContext;
+    nextSignalMetadata(signalName: string): SignalCallMetadata;
+}
+
+type EngineStatus = 'queued' | 'running' | 'completed' | 'failed' | 'cancelled';
+interface EngineSignalRequest {
+    readonly name: string;
+    readonly request: unknown;
+}
+type EngineExecutionResult<Result, Error> = {
+    readonly ok: true;
+    readonly value: Result;
+} | {
+    readonly ok: false;
+    readonly error: Error;
+};
+interface EngineExecutionRequest<_Result = unknown, _Error = unknown> {
+    readonly id: string;
+    readonly brickId?: string;
+    readonly params: unknown;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly context: ExecutionContext;
+    readonly execute: () => Promise<EngineExecutionResult<_Result, _Error>>;
+    readonly signal: (signal: EngineSignalRequest) => Promise<unknown>;
+}
+interface EngineExecutionHandle<Result = unknown, Error = unknown> {
+    readonly id: string;
+    readonly result: Promise<EngineExecutionResult<Result, Error>>;
+    readonly status: () => Promise<EngineStatus>;
+    readonly cancel: (reason?: string) => Promise<void>;
+    readonly signal: (signal: EngineSignalRequest) => Promise<unknown>;
+}
+
+interface Worker {
+    start<Result, Failure>(request: EngineExecutionRequest<Result, Failure>): EngineExecutionHandle<Result, Failure>;
+}
+
+type Providers = Readonly<Record<string, unknown>>;
+interface AnyLayer {
+    readonly id: string;
+    readonly entries: Readonly<Record<string, unknown>>;
+    readonly providers: Readonly<Record<string, unknown>>;
+    provide?(values: Readonly<Record<string, unknown>>): AnyLayer;
+    override?(values: Readonly<Record<string, unknown>>): AnyLayer;
+}
+type LayerEntry = BrickImplementation<any> | AnyLayer;
+type LayerEntries = Readonly<Record<string, LayerEntry>>;
+declare const requirementConflictBrand: unique symbol;
+type RequirementConflict<Key extends PropertyKey, Left = unknown, Right = unknown> = {
+    readonly [requirementConflictBrand]: Key;
+    readonly left: Left;
+    readonly right: Right;
+};
+type EntryRequirements<Entry> = Entry extends BrickImplementation<infer Spec extends Brick> ? RequirementsOf<Spec> : Entry extends {
+    readonly entries: infer Entries extends LayerEntries;
+} ? RequirementsFromEntries<Entries> : Record<never, never>;
+type RequirementUnion<Entries extends LayerEntries> = EntryRequirements<Entries[keyof Entries]>;
+type KeysOfUnion<Value> = Value extends Value ? keyof Value : never;
+type ValuesForKey<Value, Key extends PropertyKey> = Value extends Value ? Key extends keyof Value ? Value[Key] : never : never;
+type RequirementsWithKey<Value, Key extends PropertyKey> = Value extends Value ? Key extends keyof Value ? Value : never : never;
+type AreMutuallyAssignable<Left, Right> = [Left] extends [Right] ? [Right] extends [Left] ? false : true : true;
+type HasIncompatibleRequirement<Requirements, Key extends PropertyKey, Left = RequirementsWithKey<Requirements, Key>, Right = RequirementsWithKey<Requirements, Key>> = Left extends Record<Key, unknown> ? Right extends Record<Key, unknown> ? AreMutuallyAssignable<Left[Key], Right[Key]> : never : never;
+type ResolveRequirement<Key extends PropertyKey, Requirements> = true extends HasIncompatibleRequirement<Requirements, Key> ? RequirementConflict<Key, ValuesForKey<Requirements, Key>, ValuesForKey<Requirements, Key>> : ValuesForKey<Requirements, Key>;
+type RequirementsFromEntries<Entries extends LayerEntries> = {
+    readonly [Key in KeysOfUnion<RequirementUnion<Entries>>]: ResolveRequirement<Key, RequirementUnion<Entries>>;
+};
+type EffectiveRequirementUnion<Entries extends LayerEntries, Depth extends readonly unknown[] = []> = {
+    [Key in keyof Entries]: Entries[Key] extends BrickImplementation<infer F extends Brick> ? EffectiveRequirementsOf<F> : Entries[Key] extends {
+        readonly entries: infer Nested extends LayerEntries;
+    } ? Depth['length'] extends 16 ? Readonly<Record<string, never>> : EffectiveRequirementUnion<Nested, [...Depth, unknown]> : never;
+}[keyof Entries];
+type EffectiveRequirementsFromEntries<Entries extends LayerEntries> = {
+    readonly [Key in KeysOfUnion<EffectiveRequirementUnion<Entries>>]: ResolveRequirement<Key, EffectiveRequirementUnion<Entries>>;
+};
+type BrickOfEntry<Entry> = Entry extends BrickImplementation<infer F extends Brick> ? F : never;
+type FlattenedBrickEntryForAlias<Entries extends LayerEntries, Alias extends PropertyKey, Path extends readonly PropertyKey[] = readonly []> = {
+    [Key in keyof Entries]: Entries[Key] extends BrickImplementation<infer _F extends Brick> ? Key extends Alias ? {
+        readonly path: readonly [...Path, Key];
+        readonly implementation: Entries[Key];
+        readonly scope: Entries;
+    } : never : Entries[Key] extends {
+        readonly id: infer Id extends PropertyKey;
+        readonly entries: infer Nested extends LayerEntries;
+    } ? FlattenedBrickEntryForAlias<Nested, Alias, readonly [...Path, Id]> : never;
+}[keyof Entries];
+type IsUnion<Value, Whole = Value> = Value extends Value ? [Whole] extends [Value] ? false : true : never;
+type UniqueGlobalBrickEntryForAlias<RootEntries extends LayerEntries, Alias extends PropertyKey, Match = FlattenedBrickEntryForAlias<RootEntries, Alias>> = [Match] extends [never] ? never : true extends IsUnion<Match> ? never : Match;
+type ScopedBrickEntryForAlias<RootEntries extends LayerEntries, ScopeEntries extends LayerEntries, Alias extends PropertyKey, Match = FlattenedBrickEntryForAlias<RootEntries, Alias>> = Match extends {
+    readonly scope: infer CandidateScope extends LayerEntries;
+} ? [CandidateScope] extends [ScopeEntries] ? [ScopeEntries] extends [CandidateScope] ? Match : never : never : never;
+type ResolvedBrickEntry<RootEntries extends LayerEntries, ScopeEntries extends LayerEntries, Alias extends PropertyKey, Direct = ScopedBrickEntryForAlias<RootEntries, ScopeEntries, Alias>> = [Direct] extends [never] ? UniqueGlobalBrickEntryForAlias<RootEntries, Alias> : Direct;
+type ResolvedBrickEntryForSignals<RootEntries extends LayerEntries, ScopeEntries extends LayerEntries, Alias extends PropertyKey> = ResolvedBrickEntry<RootEntries, ScopeEntries, Alias>;
+type OwnSignalHandlers<F extends Brick> = SignalsOf<F> extends SignalDefinitions ? keyof SignalsOf<F> extends never ? Record<never, never> : BoundarySignalHandlers<SignalsOf<F>> : Record<never, never>;
+type NamespacedSignalHandlers<Path extends readonly PropertyKey[], Handlers> = keyof Handlers extends never ? Record<never, never> : Path extends readonly [
+    infer Head extends PropertyKey,
+    ...infer Tail extends readonly PropertyKey[]
+] ? {
+    readonly [Key in Head]: NamespacedSignalHandlers<Tail, Handlers>;
+} : Handlers;
+type ResolvedSignalHandlers<RootEntries extends LayerEntries, Alias extends PropertyKey, Resolved, Depth extends readonly unknown[] = []> = Resolved extends {
+    readonly path: infer Path extends readonly PropertyKey[];
+    readonly implementation: BrickImplementation<infer ResolvedBrick extends Brick>;
+    readonly scope: infer ResolvedScope extends LayerEntries;
+} ? NamespacedSignalHandlers<Path, OwnSignalHandlers<ResolvedBrick>> & OwnSelectedSignalHandlers<RootEntries, ResolvedScope, ResolvedBrick, Depth> : Resolved extends {
+    readonly implementation: BrickImplementation<infer ResolvedBrick extends Brick>;
+    readonly scope: infer ResolvedScope extends LayerEntries;
+} ? NamespacedSignalHandlers<readonly [Alias], OwnSignalHandlers<ResolvedBrick>> & OwnSelectedSignalHandlers<RootEntries, ResolvedScope, ResolvedBrick, Depth> : Record<never, never>;
+type OwnSelectedSignalHandlers<RootEntries extends LayerEntries, ScopeEntries extends LayerEntries, F extends Brick, Depth extends readonly unknown[] = []> = Depth['length'] extends 16 ? keyof DependenciesOf<F> extends never ? Record<never, never> : never : UnionToIntersection$1<{
+    readonly [Alias in keyof DependenciesOf<F>]: ResolvedBrickEntryForSignals<RootEntries, ScopeEntries, Alias> extends infer Resolved ? ResolvedSignalHandlers<RootEntries, Alias, Resolved, [...Depth, unknown]> : Record<never, never>;
+}[keyof DependenciesOf<F>]>;
+type HasIncompatibleDependencyAlias<RootEntries extends LayerEntries, ScopeEntries extends LayerEntries, F extends Brick> = true extends {
+    readonly [Alias in keyof DependenciesOf<F>]: [
+        ResolvedBrickEntry<RootEntries, ScopeEntries, Alias>
+    ] extends [never] ? false : ResolvedBrickEntry<RootEntries, ScopeEntries, Alias> extends {
+        readonly implementation: infer Implementation;
+    } ? BrickOfEntry<Implementation> extends DependenciesOf<F>[Alias] ? false : true : false;
+}[keyof DependenciesOf<F>] ? true : false;
+type ValidateDependencyAliases<RootEntries extends LayerEntries, Entries extends LayerEntries = RootEntries> = {
+    readonly [Key in keyof Entries]: Entries[Key] extends BrickImplementation<infer F extends Brick> ? HasIncompatibleDependencyAlias<RootEntries, Entries, F> extends true ? never : Entries[Key] : Entries[Key] extends {
+        readonly entries: infer Nested extends LayerEntries;
+    } ? Entries[Key] & {
+        readonly entries: ValidateDependencyAliases<RootEntries, Nested>;
+    } : Entries[Key];
+};
+type ProviderUnion<Entries extends LayerEntries> = {
+    readonly [Key in keyof Entries]: Entries[Key] extends Layer$1<string, infer NestedEntries, infer NestedProvided> ? EffectiveLayerProviders<NestedEntries, NestedProvided> : Record<never, never>;
+}[keyof Entries];
+type UnionToIntersection$1<Value> = (Value extends Value ? (value: Value) => void : never) extends (value: infer Intersection) => void ? Intersection : never;
+type EffectiveLayerProviders<Entries extends LayerEntries, Provided extends Providers> = Provided & Omit<UnionToIntersection$1<ProviderUnion<Entries>>, keyof Provided>;
+type ExactKeys<Values, Allowed> = Values & Record<Exclude<keyof Values, keyof Allowed>, never>;
+type ProvideValues<Entries extends LayerEntries, Provided extends Providers> = Partial<Omit<EffectiveRequirementsFromEntries<Entries>, keyof EffectiveLayerProviders<Entries, Provided>>>;
+type OverrideValues<Entries extends LayerEntries, Provided extends Providers> = Partial<Pick<EffectiveRequirementsFromEntries<Entries>, keyof EffectiveLayerProviders<Entries, Provided> & keyof EffectiveRequirementsFromEntries<Entries>>>;
+type DependencyBrick$1<Value> = Value extends Brick ? Value : never;
+type SuppliedDependencyNode<RootEntries extends LayerEntries, ScopeEntries extends LayerEntries, F extends Brick, Depth extends readonly unknown[]> = {
+    readonly brick: BrickImplementation<F>;
+} & (keyof ScopedUnresolvedDependencies<RootEntries, ScopeEntries, F, Depth> extends never ? {
+    readonly dependencies?: never;
+} : {
+    readonly dependencies: ScopedUnresolvedDependencies<RootEntries, ScopeEntries, F, Depth>;
+});
+type UnresolvedDirectDependency<RootEntries extends LayerEntries, ScopeEntries extends LayerEntries, F extends Brick, Alias extends keyof DependenciesOf<F>, Depth extends readonly unknown[]> = {
+    readonly [Key in Alias]: SuppliedDependencyNode<RootEntries, ScopeEntries, DependencyBrick$1<DependenciesOf<F>[Alias]>, [
+        ...Depth,
+        unknown
+    ]>;
+};
+type UnresolvedDependencyBranch<RootEntries extends LayerEntries, ScopeEntries extends LayerEntries, F extends Brick, Alias extends keyof DependenciesOf<F>, Depth extends readonly unknown[]> = ResolvedBrickEntry<RootEntries, ScopeEntries, Alias> extends infer Resolved ? [Resolved] extends [never] ? UnresolvedDirectDependency<RootEntries, ScopeEntries, F, Alias, Depth> : Resolved extends {
+    readonly implementation: BrickImplementation<infer ResolvedBrick extends Brick>;
+    readonly scope: infer ResolvedScope extends LayerEntries;
+} ? ScopedUnresolvedDependencies<RootEntries, ResolvedScope, ResolvedBrick, [
+    ...Depth,
+    unknown
+]> extends infer Children ? keyof Children extends never ? Record<never, never> : string extends keyof Children ? Children : {
+    readonly [Key in Alias]: {
+        readonly dependencies: Children;
+    };
+} : Record<never, never> : UnresolvedDirectDependency<RootEntries, ScopeEntries, F, Alias, Depth> : UnresolvedDirectDependency<RootEntries, ScopeEntries, F, Alias, Depth>;
+type ScopedUnresolvedDependencies<RootEntries extends LayerEntries, ScopeEntries extends LayerEntries, F extends Brick, Depth extends readonly unknown[] = []> = Depth['length'] extends 16 ? {
+    readonly [Alias in keyof DependenciesOf<F>]: {
+        readonly brick: AnyBrickImplementation;
+        readonly dependencies: Readonly<Record<string, unknown>>;
+    };
+} : UnionToIntersection$1<{
+    readonly [Alias in keyof DependenciesOf<F>]: UnresolvedDependencyBranch<RootEntries, ScopeEntries, F, Alias, Depth>;
+}[keyof DependenciesOf<F>]>;
+type UnresolvedDependencies<RootEntries extends LayerEntries, ScopeEntries extends LayerEntries, F extends Brick> = ScopedUnresolvedDependencies<RootEntries, ScopeEntries, F>;
+type SuppliedNodeSignalHandlers<Node> = Node extends {
+    readonly brick: BrickImplementation<infer F extends Brick>;
+    readonly dependencies?: infer Dependencies;
+} ? OwnSignalHandlers<F> & SuppliedDependencySignalHandlers<Dependencies> : Node extends {
+    readonly dependencies: infer Dependencies;
+} ? SuppliedDependencySignalHandlers<Dependencies> : Record<never, never>;
+type LayerSignalHandlersForDependencies<RootEntries extends LayerEntries, ScopeEntries extends LayerEntries, F extends Brick, Deps> = UnionToIntersection$1<{
+    readonly [Alias in keyof DependenciesOf<F>]: Alias extends keyof Deps ? Deps[Alias] extends {
+        readonly brick: BrickImplementation<infer SuppliedBrick extends Brick>;
+    } ? LayerSignalHandlersForDependencies<RootEntries, ScopeEntries, SuppliedBrick, Deps[Alias] extends {
+        readonly dependencies: infer SuppliedDependencies;
+    } ? SuppliedDependencies : Record<never, never>> : ResolvedSignalHandlers<RootEntries, Alias, ResolvedBrickEntry<RootEntries, ScopeEntries, Alias>> : ResolvedSignalHandlers<RootEntries, Alias, ResolvedBrickEntry<RootEntries, ScopeEntries, Alias>> extends infer Handlers ? Handlers : Record<never, never>;
+}[keyof DependenciesOf<F>]>;
+type SuppliedDependencySignalHandlers<Deps> = string extends keyof Deps ? Record<never, never> : {
+    readonly [Alias in keyof Deps as keyof SuppliedNodeSignalHandlers<Deps[Alias]> extends never ? never : Alias]: SuppliedNodeSignalHandlers<Deps[Alias]>;
+};
+type BoundBrickRunOptions<F extends Brick, RootId extends string, RootEntries extends LayerEntries, ScopeEntries extends LayerEntries, Provided extends Providers, BrickPath extends readonly PropertyKey[]> = Omit<BrickRunOptions<F>, 'requirements' | 'dependencies' | 'signals'> & (keyof Omit<EffectiveRequirementsOf<F>, keyof Provided> extends never ? {
+    readonly requirements?: never;
+} : {
+    readonly requirements: Omit<EffectiveRequirementsOf<F>, keyof Provided>;
+}) & (keyof UnresolvedDependencies<RootEntries, ScopeEntries, F> extends never ? {
+    readonly dependencies?: never;
+} : {
+    readonly dependencies: UnresolvedDependencies<RootEntries, ScopeEntries, F>;
+}) & (keyof (OwnSignalHandlers<F> & LayerSignalHandlersForDependencies<RootEntries, ScopeEntries, F, UnresolvedDependencies<RootEntries, ScopeEntries, F>> & SuppliedDependencySignalHandlers<UnresolvedDependencies<RootEntries, ScopeEntries, F>>) extends never ? {
+    readonly signals?: never;
+} : {
+    readonly signals: NamespacedSignalHandlers<BrickPath, OwnSignalHandlers<F>> & NamespacedSignalHandlers<readonly [RootId], LayerSignalHandlersForDependencies<RootEntries, ScopeEntries, F, UnresolvedDependencies<RootEntries, ScopeEntries, F>>> & SuppliedDependencySignalHandlers<UnresolvedDependencies<RootEntries, ScopeEntries, F>>;
+});
+type BoundBrickRunOptionArgs<F extends Brick, RootId extends string, RootEntries extends LayerEntries, ScopeEntries extends LayerEntries, Provided extends Providers, BrickPath extends readonly PropertyKey[]> = keyof Omit<EffectiveRequirementsOf<F>, keyof Provided> extends never ? keyof UnresolvedDependencies<RootEntries, ScopeEntries, F> extends never ? keyof (OwnSignalHandlers<F> & LayerSignalHandlersForDependencies<RootEntries, ScopeEntries, F, UnresolvedDependencies<RootEntries, ScopeEntries, F>> & SuppliedDependencySignalHandlers<UnresolvedDependencies<RootEntries, ScopeEntries, F>>) extends never ? readonly [
+    options?: BoundBrickRunOptions<F, RootId, RootEntries, ScopeEntries, Provided, BrickPath>
+] : readonly [
+    options: BoundBrickRunOptions<F, RootId, RootEntries, ScopeEntries, Provided, BrickPath>
+] : readonly [
+    options: BoundBrickRunOptions<F, RootId, RootEntries, ScopeEntries, Provided, BrickPath>
+] : readonly [
+    options: BoundBrickRunOptions<F, RootId, RootEntries, ScopeEntries, Provided, BrickPath>
+];
+type BoundBrick<F extends Brick, RootId extends string, RootEntries extends LayerEntries, ScopeEntries extends LayerEntries, Provided extends Providers, BrickPath extends readonly PropertyKey[]> = {
+    readonly handler: BrickImplementation<F>['handler'];
+    run(params: ParamsOf<F>, ...options: BoundBrickRunOptionArgs<F, RootId, RootEntries, ScopeEntries, Provided, BrickPath>): BrickRun<EffectiveErrorsOf<F>, ResultOf<F>>;
+};
+type BoundEntries<RootId extends string, RootEntries extends LayerEntries, Entries extends LayerEntries, EffectiveProvided extends Providers, LayerPath extends readonly PropertyKey[]> = {
+    readonly [Key in keyof Entries]: Entries[Key] extends BrickImplementation<infer F extends Brick> ? BoundBrick<F, RootId, RootEntries, Entries, EffectiveProvided, readonly [...LayerPath, Key]> : Entries[Key] extends Layer$1<infer Id, infer Nested, infer NestedProvided> ? BoundLayer<Id, Nested, NestedProvided, RootEntries, RootId, EffectiveProvided, readonly [...LayerPath, Id]> : never;
+};
+type BoundLayer<Id extends string, Entries extends LayerEntries, Provided extends Providers, RootEntries extends LayerEntries = Entries, RootId extends string = Id, EffectiveProvided extends Providers = EffectiveLayerProviders<Entries, Provided>, LayerPath extends readonly PropertyKey[] = readonly [Id]> = LayerState<Id, Entries, Provided> & BoundEntries<RootId, RootEntries, Entries, EffectiveProvided, LayerPath>;
+interface LayerState<Id extends string = string, Entries extends LayerEntries = LayerEntries, Provided extends Providers = Providers> {
+    readonly id: Id;
+    readonly entries: Readonly<Entries>;
+    readonly providers: Readonly<Provided>;
+    provide<const Values extends ProvideValues<Entries, Provided>>(values: ExactKeys<Values, ProvideValues<Entries, Provided>>): BoundLayer<Id, Entries, Provided & Values>;
+    override<const Values extends OverrideValues<Entries, Provided>>(values: ExactKeys<Values, OverrideValues<Entries, Provided>>): BoundLayer<Id, Entries, Omit<Provided, keyof Values> & Values>;
+}
+type Layer$1<Id extends string = string, Entries extends LayerEntries = LayerEntries, Provided extends Providers = Record<never, never>> = BoundLayer<Id, Entries, Provided>;
+interface LayerConstructor {
+    new <const Id extends string, const Entries extends LayerEntries>(id: Id & ValidPathSegment<Id>, entries: Entries & ValidateDependencyAliases<Entries> & ValidatePathSegmentKeys<Entries> & Record<Extract<keyof Entries, ReservedLayerEntryName>, never>): Layer$1<Id, Entries>;
+}
+type ReservedLayerEntryName = 'id' | 'entries' | 'providers' | 'provide' | 'override';
+type LayerEntriesOf<Value> = Value extends {
+    readonly entries: infer Entries extends LayerEntries;
+} ? Entries : never;
+type LayerProvidersOf<Value> = Value extends {
+    readonly providers: infer Provided extends Providers;
+} ? Provided : never;
+type LayerRequirementsOf<Value> = Value extends {
+    readonly entries: infer Entries extends LayerEntries;
+} ? RequirementsFromEntries<Entries> : never;
+type LayerUnprovidedRequirementsOf<Value> = Value extends {
+    readonly entries: infer Entries extends LayerEntries;
+    readonly providers: infer Provided extends Providers;
+} ? Omit<EffectiveRequirementsFromEntries<Entries>, keyof EffectiveLayerProviders<Entries, Provided>> : never;
+interface FlattenedLayerEntry {
+    readonly id: string;
+    readonly key: string;
+    readonly layerPath: readonly string[];
+    readonly implementation: BrickImplementation<any>;
+}
+
+type MatchingOutcome<Success, Error> = {
+    readonly ok: true;
+    readonly value: Success;
+} | {
+    readonly ok: false;
+    readonly error: Error;
+};
+type MatchingThunk<Success, Error> = () => MatchingOutcome<Success, Error> | Promise<MatchingOutcome<Success, Error>>;
+type SupportedPattern<Input> = P.Pattern<Input>;
+type MatchedError<Error, Pattern extends SupportedPattern<Error>> = P.narrow<Error, Pattern>;
+type RecoveryValue<Handler> = Exclude<Awaited<Handler>, undefined>;
+type IsEqual<Left, Right> = (<Value>() => Value extends Left ? 1 : 2) extends <Value>() => Value extends Right ? 1 : 2 ? (<Value>() => Value extends Right ? 1 : 2) extends <Value>() => Value extends Left ? 1 : 2 ? true : false : false;
+type CoveredError<Error, Pattern extends SupportedPattern<Error>> = IsEqual<MatchedError<Error, Pattern>, Error> extends true ? Error : Pattern extends string | number | boolean | bigint | symbol | null | undefined ? Extract<Error, Pattern> : Pattern extends {
+    readonly type: infer Type;
+} ? Exclude<keyof Pattern, 'type'> extends never ? Extract<Error, {
+    readonly type: Type;
+}> : never : never;
+type RemainingErrors<Error, Pattern extends SupportedPattern<Error>, HandlerResult> = undefined extends Awaited<HandlerResult> ? Error : Exclude<Error, CoveredError<Error, Pattern>>;
+interface MatchingBuilder<Error, InitialSuccess, LocalResult = InitialSuccess, RemainingError = Error> extends PromiseLike<MatchingOutcome<LocalResult, RemainingError>> {
+    with<const Pattern extends SupportedPattern<RemainingError>, HandlerResult>(pattern: Pattern extends readonly unknown[] ? never : Pattern, handler: (error: MatchedError<RemainingError, Pattern>) => HandlerResult | Promise<HandlerResult>): MatchingBuilder<Error, InitialSuccess, LocalResult | RecoveryValue<HandlerResult>, RemainingErrors<RemainingError, Pattern, HandlerResult>>;
+}
+
+type RunMetadata = Readonly<Record<string, unknown>>;
+interface BrickRunControls {
+    readonly id: string;
+    status(): Promise<EngineStatus>;
+    cancel(reason?: string): Promise<void>;
+}
+interface IncompleteBrickRun<Error, InitialSuccess, LocalResult = InitialSuccess, RemainingError = Error> extends BrickRunControls {
+    readonly unhandledErrors: RemainingError;
+    readonly then: (invalidOnFulfilled: never) => never;
+    with<const Pattern extends SupportedPattern<RemainingError>, HandlerResult>(pattern: Pattern extends readonly unknown[] ? never : Pattern, handler: (error: MatchedError<RemainingError, Pattern>) => HandlerResult | Promise<HandlerResult>): BrickRun<Error, InitialSuccess, LocalResult | RecoveryValue<HandlerResult>, RemainingErrors<RemainingError, Pattern, HandlerResult>>;
+}
+interface CompleteBrickRun<Error, InitialSuccess, LocalResult = InitialSuccess> extends BrickRunControls, PromiseLike<LocalResult> {
+    with<const Pattern extends SupportedPattern<never>, HandlerResult>(pattern: Pattern extends readonly unknown[] ? never : Pattern, handler: (error: MatchedError<never, Pattern>) => HandlerResult | Promise<HandlerResult>): BrickRun<Error, InitialSuccess, LocalResult | RecoveryValue<HandlerResult>, never>;
+}
+type BrickRun<Error, InitialSuccess, LocalResult = InitialSuccess, RemainingError = Error> = [RemainingError] extends [never] ? CompleteBrickRun<Error, InitialSuccess, LocalResult> : IncompleteBrickRun<Error, InitialSuccess, LocalResult, RemainingError>;
+
+type Empty = Record<never, never>;
+type DeclaredProperty<F, Key extends PropertyKey, Default> = F extends Record<Key, infer Value> ? Value : Default;
+type ParamsOf<F extends Brick> = F['params'];
+type ResultOf<F extends Brick> = F['result'];
+type ErrorsOf<F extends Brick> = DeclaredProperty<F, 'errors', never>;
+type RequirementsOf<F extends Brick> = DeclaredProperty<F, 'requires', Empty> extends object ? DeclaredProperty<F, 'requires', Empty> : Empty;
+type DependenciesOf<F extends Brick> = DeclaredProperty<F, 'depends', Empty> extends object ? DeclaredProperty<F, 'depends', Empty> : Empty;
+type SignalsOf<F extends Brick> = DeclaredProperty<F, 'signals', Empty> extends object ? DeclaredProperty<F, 'signals', Empty> : Empty;
+type ValidBrick<F extends Brick> = HasValidPathSegmentKeys<DependenciesOf<F>> extends true ? HasValidPathSegmentKeys<SignalsOf<F>> extends true ? F : never : never;
+type BrickOf<Implementation> = Implementation extends BrickImplementation<infer F> ? F : never;
+type AnyBrickImplementation = BrickImplementation<any>;
+type DependencyBrick<Value> = Value extends Brick ? Value : never;
+type UnionToIntersection<Value> = (Value extends Value ? (value: Value) => void : never) extends (value: infer Intersection) => void ? Intersection : never;
+type EffectiveErrorsFromDependencies<F extends Brick, Depth extends readonly unknown[]> = {
+    [Key in keyof DependenciesOf<F>]: EffectiveErrorsOf<DependencyBrick<DependenciesOf<F>[Key]>, Depth>;
+}[keyof DependenciesOf<F>];
+type EffectiveRequirementsFromDependencies<F extends Brick, Depth extends readonly unknown[]> = UnionToIntersection<{
+    [Key in keyof DependenciesOf<F>]: EffectiveRequirementsOf<DependencyBrick<DependenciesOf<F>[Key]>, Depth>;
+}[keyof DependenciesOf<F>]>;
+type EffectiveDependenciesFromDependencies<F extends Brick, Depth extends readonly unknown[]> = UnionToIntersection<{
+    [Key in keyof DependenciesOf<F>]: EffectiveDependenciesOf<DependencyBrick<DependenciesOf<F>[Key]>, Depth>;
+}[keyof DependenciesOf<F>]>;
+type EffectiveSignalsFromDependencies<F extends Brick, Depth extends readonly unknown[]> = UnionToIntersection<{
+    [Key in keyof DependenciesOf<F>]: EffectiveSignalsOf<DependencyBrick<DependenciesOf<F>[Key]>, Depth>;
+}[keyof DependenciesOf<F>]>;
+type EffectiveErrorsOf<F extends Brick, Depth extends readonly unknown[] = []> = Depth['length'] extends 16 ? ErrorsOf<F> : ErrorsOf<F> | EffectiveErrorsFromDependencies<F, [...Depth, unknown]>;
+type EffectiveRequirementsOf<F extends Brick, Depth extends readonly unknown[] = []> = RequirementsOf<F> & (Depth['length'] extends 16 ? Empty : EffectiveRequirementsFromDependencies<F, [...Depth, unknown]>);
+type EffectiveDependenciesOf<F extends Brick, Depth extends readonly unknown[] = []> = {
+    readonly [Key in keyof DependenciesOf<F>]: BrickImplementation<DependencyBrick<DependenciesOf<F>[Key]>>;
+} & (Depth['length'] extends 16 ? Empty : EffectiveDependenciesFromDependencies<F, [...Depth, unknown]>);
+type EffectiveSignalsOf<F extends Brick, Depth extends readonly unknown[] = []> = SignalsOf<F> & (Depth['length'] extends 16 ? Empty : EffectiveSignalsFromDependencies<F, [...Depth, unknown]>);
+type DependencyNodes<F extends Brick, Depth extends readonly unknown[] = []> = {
+    readonly [Alias in keyof DependenciesOf<F>]: DependencyNode<DependencyBrick<DependenciesOf<F>[Alias]>, Depth>;
+};
+type DependencyNode<F extends Brick, Depth extends readonly unknown[] = []> = Depth['length'] extends 16 ? {
+    readonly brick: BrickImplementation<F>;
+} & (keyof DependenciesOf<F> extends never ? {
+    readonly dependencies?: never;
+} : {
+    readonly dependencies: {
+        readonly [Alias in keyof DependenciesOf<F>]: {
+            readonly brick: AnyBrickImplementation;
+            readonly dependencies: Readonly<Record<string, unknown>>;
+        };
+    };
+}) : {
+    readonly brick: BrickImplementation<F>;
+} & (keyof DependenciesOf<F> extends never ? {
+    readonly dependencies?: never;
+} : {
+    readonly dependencies: DependencyNodes<F, [...Depth, unknown]>;
+});
+type DependencySignalHandlers<F extends Brick, Depth extends readonly unknown[] = []> = {
+    readonly [Alias in keyof DependenciesOf<F> as keyof BrickSignalHandlers<DependencyBrick<DependenciesOf<F>[Alias]>, [
+        ...Depth,
+        unknown
+    ]> extends never ? never : Alias]: BrickSignalHandlers<DependencyBrick<DependenciesOf<F>[Alias]>, [...Depth, unknown]>;
+};
+type DepthFallbackSignalHandlers<F extends Brick> = keyof DependenciesOf<F> extends never ? Empty : {
+    readonly [Alias in keyof DependenciesOf<F>]: Readonly<Record<string, unknown>>;
+};
+type BrickSignalHandlers<F extends Brick, Depth extends readonly unknown[] = []> = (SignalsOf<F> extends SignalDefinitions ? keyof SignalsOf<F> extends never ? Empty : BoundarySignalHandlers<SignalsOf<F>> : Empty) & (Depth['length'] extends 16 ? DepthFallbackSignalHandlers<F> : DependencySignalHandlers<F, Depth>);
+type DependencyCallOptions<F extends Brick> = SignalsOf<F> extends SignalDefinitions ? keyof SignalsOf<F> extends never ? {
+    readonly signals?: never;
+} : {
+    readonly signals?: InternalSignalHandlers<SignalsOf<F>>;
+} : {
+    readonly signals?: never;
+};
+type DependencyFunctions<F extends Brick> = {
+    readonly [Key in keyof DependenciesOf<F>]: (params: ParamsOf<DependencyBrick<DependenciesOf<F>[Key]>>, options?: DependencyCallOptions<DependencyBrick<DependenciesOf<F>[Key]>>) => Promise<ResultOf<DependencyBrick<DependenciesOf<F>[Key]>>>;
+};
+interface BrickTools<F extends Brick> {
+    readonly fail: (error: ErrorsOf<F>) => never;
+    readonly signals: SignalsOf<F> extends SignalDefinitions ? SignalFunctions<SignalsOf<F>> : never;
+}
+type BrickHandler<F extends Brick> = (params: ParamsOf<F>, requirements: RequirementsOf<F>, dependencies: DependencyFunctions<F>, tools: BrickTools<F>) => ResultOf<F> | Promise<ResultOf<F>>;
+type RequiredSection<Key extends PropertyKey, Value> = [Key] extends [never] ? {
+    readonly [Property in never]?: never;
+} : Value;
+type RequirementsOption<F extends Brick> = RequiredSection<keyof EffectiveRequirementsOf<F>, {
+    readonly requirements: EffectiveRequirementsOf<F>;
+}>;
+type DependenciesOption<F extends Brick> = RequiredSection<keyof DependenciesOf<F>, {
+    readonly dependencies: DependencyNodes<F>;
+}>;
+type SignalsOption<F extends Brick> = keyof BrickSignalHandlers<F> extends never ? {
+    readonly signals?: never;
+} : {
+    readonly signals: BrickSignalHandlers<F>;
+};
+type BrickRunOptions<F extends Brick> = {
+    readonly worker?: Worker;
+    readonly id?: string;
+    readonly metadata?: RunMetadata;
+} & RequirementsOption<F> & DependenciesOption<F> & SignalsOption<F>;
+type BrickRunOptionArgs<F extends Brick> = keyof EffectiveRequirementsOf<F> extends never ? keyof DependenciesOf<F> extends never ? keyof BrickSignalHandlers<F> extends never ? readonly [options?: BrickRunOptions<F>] : readonly [options: BrickRunOptions<F>] : readonly [options: BrickRunOptions<F>] : readonly [options: BrickRunOptions<F>];
+interface BrickImplementation<F extends Brick = Brick> {
+    readonly handler: BrickHandler<F>;
+    run(params: ParamsOf<F>, ...options: BrickRunOptionArgs<F>): BrickRun<EffectiveErrorsOf<F>, ResultOf<F>>;
+}
+type BrickExecutionResult<F extends Brick> = {
+    readonly ok: true;
+    readonly value: ResultOf<F>;
+} | {
+    readonly ok: false;
+    readonly error: ErrorsOf<F>;
+};
+
+interface BrickConfig {
+    params: unknown;
+    result: unknown;
+    errors?: unknown;
+    requires?: object;
+    depends?: Readonly<Record<string, Brick>>;
+    signals?: SignalDefinitions;
+}
+type Brick<Config extends BrickConfig = BrickConfig> = Config;
+declare function brick<F extends Brick>(handler: F extends ValidBrick<F> ? BrickHandler<F> : never): BrickImplementation<F>;
+
+declare const Layer: LayerConstructor;
+
+declare class NonBoundarySignalHandlerChainError extends Error {
+    readonly signalName: string;
+    constructor(signalName: string);
+}
+declare class MissingSignalHandlerError extends Error {
+    readonly signalName: string;
+    constructor(signalName: string);
+}
+
+declare class LocalRunCancelledError extends Error {
+    readonly runId: string;
+    readonly reason: string | undefined;
+    constructor(runId: string, reason?: string);
+}
+declare class DuplicateLocalRunIdError extends Error {
+    readonly runId: string;
+    constructor(runId: string);
+}
+declare class LocalWorker implements Worker {
+    private readonly runIds;
+    start<Result, Failure>(request: EngineExecutionRequest<Result, Failure>): EngineExecutionHandle<Result, Failure>;
+}
+declare const localWorker: Worker;
+
+declare class UnhandledBrickFailureError extends Error {
+    readonly failure: unknown;
+    constructor(failure: unknown);
+}
+
+export { type AnyLayer, type BoundarySignalHandler, type BoundarySignalHandlers, type Brick, type BrickExecutionResult, type BrickHandler, type BrickImplementation, type BrickOf, type BrickRun, type BrickRunControls, type BrickRunOptionArgs, type BrickRunOptions, type BrickTools, type CompleteBrickRun, type DependenciesOf, type DependencyFunctions, DuplicateLocalRunIdError, type EffectiveDependenciesOf, type EffectiveErrorsOf, type EffectiveRequirementsOf, type EffectiveSignalsOf, type EngineExecutionHandle, type EngineExecutionRequest, type EngineExecutionResult, type EngineSignalRequest, type EngineStatus, type ErrorsOf, ExecutionContext, type ExecutionContextOptions, type FlattenedLayerEntry, type IncompleteBrickRun, type InternalSignalHandler, type InternalSignalHandlers, Layer, type LayerEntries, type LayerEntriesOf, type LayerEntry, type LayerProvidersOf, type LayerRequirementsOf, type LayerUnprovidedRequirementsOf, LocalRunCancelledError, LocalWorker, type MatchedError, type MatchingBuilder, type MatchingOutcome, type MatchingThunk, MissingSignalHandlerError, NonBoundarySignalHandlerChainError, type ParamsOf, type RecoveryValue, type RemainingErrors, type RequirementConflict, type RequirementsOf, type ResultOf, type RunMetadata, type SignalCallMetadata, type SignalDefinition, type SignalDefinitions, type SignalFunction, type SignalFunctions, type SignalHandlerChain, type SignalRequest, type SignalResponse, type SignalsOf, type SupportedPattern, UnhandledBrickFailureError, type Worker, brick, localWorker };