brickflow 0.0.1 → 0.0.2

package/dist/index.js

@@ -0,0 +1,755 @@
+// src/index.ts
+import { P } from "ts-pattern";
+
+// src/worker/execution.ts
+import { randomUUID } from "crypto";
+
+// src/brick/failure.ts
+var BrickFailure = class {
+  error;
+  constructor(error) {
+    this.error = error;
+  }
+};
+function failWith(error) {
+  throw new BrickFailure(error);
+}
+function readBrickFailure(value) {
+  return value instanceof BrickFailure ? value.error : void 0;
+}
+function isBrickFailure(value) {
+  return value instanceof BrickFailure;
+}
+
+// src/brick/implementation.ts
+var implementationBrand = /* @__PURE__ */ Symbol("BrickImplementation");
+function markBrickImplementation(target) {
+  Object.defineProperty(target, implementationBrand, {
+    configurable: false,
+    enumerable: false,
+    value: true,
+    writable: false
+  });
+}
+function isBrickImplementation(value) {
+  return typeof value === "object" && value !== null && Object.hasOwn(value, implementationBrand) && value[implementationBrand] === true;
+}
+async function executeBrickImplementation(implementation, params, requirements, dependencies, signals) {
+  try {
+    const value = await implementation.handler(params, requirements, dependencies, {
+      fail: failWith,
+      signals
+    });
+    return { ok: true, value };
+  } catch (error) {
+    if (!isBrickFailure(error)) throw error;
+    return { ok: false, error: readBrickFailure(error) };
+  }
+}
+
+// src/path-segment.ts
+var PATH_DELIMITER = ".";
+function assertValidPathSegment(segment) {
+  if (segment.length === 0) {
+    throw new Error("Invalid path segment: segment must not be empty");
+  }
+  if (segment.includes(PATH_DELIMITER)) {
+    throw new Error(
+      `Invalid path segment "${segment}": "${PATH_DELIMITER}" is a reserved delimiter`
+    );
+  }
+}
+
+// src/signal/namespace.ts
+function isHandler(value) {
+  return typeof value === "function";
+}
+function flattenNamespacedSignalHandlers(handlers, path = []) {
+  const flattened = /* @__PURE__ */ Object.create(null);
+  for (const [name, value] of Object.entries(handlers)) {
+    assertValidPathSegment(name);
+    const durableName = durableSignalName(path, name);
+    if (isHandler(value)) {
+      flattened[durableName] = value;
+      continue;
+    }
+    if (typeof value === "object" && value !== null) {
+      Object.assign(
+        flattened,
+        flattenNamespacedSignalHandlers(value, [...path, name])
+      );
+      continue;
+    }
+    throw new Error(`Invalid signal handler at "${durableName}"`);
+  }
+  return Object.freeze(flattened);
+}
+function durableSignalName(path, signalName) {
+  for (const segment of path) assertValidPathSegment(segment);
+  assertValidPathSegment(signalName);
+  return [...path, signalName].join(".");
+}
+function signalCallMetadata(layerPath, brickPath, signalName, callId, occurrence) {
+  const stableLayerPath = Object.freeze([...layerPath]);
+  const stableBrickPath = Object.freeze([...brickPath]);
+  return Object.freeze({
+    durableName: durableSignalName([...stableLayerPath, ...stableBrickPath], signalName),
+    signalName,
+    layerPath: stableLayerPath,
+    brickPath: stableBrickPath,
+    callId,
+    occurrence
+  });
+}
+
+// src/engine/execution-context.ts
+var ExecutionContext = class _ExecutionContext {
+  layerPath;
+  brickPath;
+  callId;
+  providers;
+  signalHandlers;
+  #signalOccurrences = /* @__PURE__ */ new Map();
+  constructor(options) {
+    const layerPath = [...options.layerPath ?? []];
+    const brickPath = [...options.brickPath ?? []];
+    for (const segment of layerPath) assertValidPathSegment(segment);
+    for (const segment of brickPath) assertValidPathSegment(segment);
+    this.layerPath = Object.freeze(layerPath);
+    this.brickPath = Object.freeze(brickPath);
+    this.callId = options.callId;
+    this.providers = options.providers ?? Object.freeze({});
+    this.signalHandlers = options.signalHandlers;
+    Object.freeze(this);
+  }
+  childLayer(segment) {
+    assertValidPathSegment(segment);
+    return new _ExecutionContext({
+      layerPath: [...this.layerPath, segment],
+      brickPath: this.brickPath,
+      callId: this.callId,
+      providers: this.providers,
+      ...this.signalHandlers ? { signalHandlers: this.signalHandlers } : {}
+    });
+  }
+  childBrick(segment, callId) {
+    assertValidPathSegment(segment);
+    return new _ExecutionContext({
+      layerPath: this.layerPath,
+      brickPath: [...this.brickPath, segment],
+      callId,
+      providers: this.providers,
+      ...this.signalHandlers ? { signalHandlers: this.signalHandlers } : {}
+    });
+  }
+  withSignalHandlers(signalHandlers) {
+    return new _ExecutionContext({
+      layerPath: this.layerPath,
+      brickPath: this.brickPath,
+      callId: this.callId,
+      providers: this.providers,
+      signalHandlers
+    });
+  }
+  nextSignalMetadata(signalName) {
+    const occurrence = (this.#signalOccurrences.get(signalName) ?? 0) + 1;
+    this.#signalOccurrences.set(signalName, occurrence);
+    return signalCallMetadata(this.layerPath, this.brickPath, signalName, this.callId, occurrence);
+  }
+};
+
+// src/signal/handler.ts
+var NonBoundarySignalHandlerChainError = class extends Error {
+  signalName;
+  constructor(signalName) {
+    super(`Signal handler chain exhausted before reaching a boundary for "${signalName}"`);
+    this.name = "NonBoundarySignalHandlerChainError";
+    this.signalName = signalName;
+  }
+};
+var MissingSignalHandlerError = class extends Error {
+  signalName;
+  constructor(signalName) {
+    super(`No boundary handler resolved signal "${signalName}"`);
+    this.name = "MissingSignalHandlerError";
+    this.signalName = signalName;
+  }
+};
+function createSignalHandlerChain(handlers, parent, boundary = false) {
+  const chain = parent ? { handlers: Object.freeze({ ...handlers }), parent, boundary } : { handlers: Object.freeze({ ...handlers }), boundary };
+  return Object.freeze(chain);
+}
+async function resolveSignal(chain, signalName, request) {
+  const handler = Object.hasOwn(chain.handlers, signalName) ? chain.handlers[signalName] : void 0;
+  if (handler) {
+    const response = await handler(request);
+    if (response !== void 0) {
+      return response;
+    }
+  }
+  if (chain.parent) {
+    return resolveSignal(chain.parent, signalName, request);
+  }
+  if (chain.boundary) {
+    throw new MissingSignalHandlerError(signalName);
+  }
+  throw new NonBoundarySignalHandlerChainError(signalName);
+}
+
+// src/signal/functions.ts
+function createSignalFunctions(context, dispatch) {
+  const functions = /* @__PURE__ */ new Map();
+  const target = Object.freeze({});
+  return new Proxy(target, {
+    get(_target, property) {
+      if (typeof property !== "string") return void 0;
+      assertValidPathSegment(property);
+      let signal = functions.get(property);
+      if (!signal) {
+        signal = async (request) => {
+          const metadata = context.nextSignalMetadata(property);
+          if (context.signalHandlers) {
+            return resolveSignal(context.signalHandlers, metadata.durableName, request);
+          }
+          if (dispatch) {
+            return dispatch({ name: metadata.durableName, request });
+          }
+          throw new Error(`No signal dispatch configured for "${metadata.durableName}"`);
+        };
+        functions.set(property, signal);
+      }
+      return signal;
+    }
+  });
+}
+
+// src/worker/local-worker.ts
+var LocalRunCancelledError = class extends Error {
+  runId;
+  reason;
+  constructor(runId, reason) {
+    super(
+      reason === void 0 ? `Local run "${runId}" was cancelled` : `Local run "${runId}" was cancelled: ${reason}`
+    );
+    this.name = "LocalRunCancelledError";
+    this.runId = runId;
+    this.reason = reason;
+  }
+};
+var DuplicateLocalRunIdError = class extends Error {
+  runId;
+  constructor(runId) {
+    super(`Local run ID "${runId}" already exists`);
+    this.name = "DuplicateLocalRunIdError";
+    this.runId = runId;
+  }
+};
+var LocalRun = class {
+  constructor(request) {
+    this.request = request;
+    this.id = request.id;
+    this.result = new Promise((resolve, reject) => {
+      this.rejectResult = reject;
+      queueMicrotask(async () => {
+        if (this.cancellation !== void 0) return;
+        this.currentStatus = "running";
+        try {
+          const result = await this.request.execute();
+          if (this.cancellation !== void 0) return;
+          this.currentStatus = result.ok ? "completed" : "failed";
+          resolve(result);
+        } catch (error) {
+          if (this.cancellation !== void 0) return;
+          this.currentStatus = "failed";
+          reject(error);
+        }
+      });
+    });
+  }
+  request;
+  id;
+  result;
+  currentStatus = "queued";
+  cancellation;
+  rejectResult;
+  async status() {
+    return this.currentStatus;
+  }
+  async cancel(reason) {
+    if (this.cancellation !== void 0 || this.currentStatus === "completed" || this.currentStatus === "failed") {
+      return;
+    }
+    this.cancellation = new LocalRunCancelledError(this.id, reason);
+    this.currentStatus = "cancelled";
+    this.rejectResult(this.cancellation);
+  }
+  async signal(signal) {
+    if (this.cancellation !== void 0) throw this.cancellation;
+    return this.request.signal(signal);
+  }
+};
+var LocalWorker = class {
+  runIds = /* @__PURE__ */ new Set();
+  start(request) {
+    if (this.runIds.has(request.id)) throw new DuplicateLocalRunIdError(request.id);
+    this.runIds.add(request.id);
+    return new LocalRun(request);
+  }
+};
+var localWorker = new LocalWorker();
+
+// src/worker/run.ts
+import { isMatching } from "ts-pattern";
+var UnhandledBrickFailureError = class extends Error {
+  failure;
+  constructor(failure) {
+    super(`Unhandled Brick failure: ${readableFailure(failure)}`);
+    this.name = "UnhandledBrickFailureError";
+    this.failure = failure;
+  }
+};
+function readableFailure(failure) {
+  if (typeof failure === "string") return failure;
+  try {
+    return JSON.stringify(failure);
+  } catch {
+    return String(failure);
+  }
+}
+var BrickRunImplementation = class _BrickRunImplementation {
+  id;
+  #handle;
+  #handlers;
+  #execution;
+  constructor(handle, handlers = []) {
+    this.id = handle.id;
+    this.#handle = handle;
+    this.#handlers = Object.freeze([...handlers]);
+    Object.freeze(this);
+  }
+  status() {
+    return this.#handle.status();
+  }
+  cancel(reason) {
+    return this.#handle.cancel(reason);
+  }
+  with(pattern, handler) {
+    return new _BrickRunImplementation(this.#handle, [
+      ...this.#handlers,
+      { pattern, handler }
+    ]);
+  }
+  // biome-ignore lint/suspicious/noThenProperty: exhaustive BrickRun values are intentionally PromiseLike
+  then(onfulfilled, onrejected) {
+    this.#execution ??= this.#execute();
+    return this.#execution.then(onfulfilled, onrejected);
+  }
+  async #execute() {
+    const outcome = await this.#handle.result;
+    if (outcome.ok) return outcome.value;
+    for (const registered of this.#handlers) {
+      if (!isMatching(registered.pattern)(outcome.error)) continue;
+      const recovered = await registered.handler(outcome.error);
+      if (recovered !== void 0) return recovered;
+      throw new UnhandledBrickFailureError(outcome.error);
+    }
+    throw new UnhandledBrickFailureError(outcome.error);
+  }
+};
+function createBrickRun(handle) {
+  return new BrickRunImplementation(handle);
+}
+
+// src/worker/execution.ts
+function directSignalChain(handlers) {
+  return createSignalHandlerChain(flattenNamespacedSignalHandlers(handlers), void 0, true);
+}
+async function executeResolvedBrick(entry, params, options, context) {
+  const implementation = entry.implementation;
+  const dependencies = new Proxy(/* @__PURE__ */ Object.create(null), {
+    get(_target, property) {
+      if (typeof property !== "string") return void 0;
+      assertValidPathSegment(property);
+      const dependencyEntry = options.resolveDependency(entry, property);
+      return async (dependencyParams, callOptions) => {
+        const signalPath = dependencyEntry.signalPath ?? dependencyEntry.suppliedPath ?? dependencyEntry.id?.split(".") ?? [dependencyEntry.key];
+        const layerPath = signalPath.slice(0, -1);
+        const brickPath = [signalPath.at(-1) ?? dependencyEntry.key];
+        const parentSignalHandlers = context.signalHandlers;
+        const localHandlers = callOptions?.signals ? createSignalHandlerChain(
+          Object.fromEntries(
+            Object.entries(callOptions.signals).map(([name, handler]) => {
+              assertValidPathSegment(name);
+              return [[...signalPath, name].join("."), handler];
+            })
+          ),
+          parentSignalHandlers,
+          false
+        ) : parentSignalHandlers;
+        const dependencyContext = new ExecutionContext({
+          layerPath,
+          brickPath,
+          callId: context.callId,
+          providers: context.providers,
+          ...localHandlers ? { signalHandlers: localHandlers } : {}
+        });
+        const outcome = await executeResolvedBrick(
+          dependencyEntry,
+          dependencyParams,
+          options,
+          dependencyContext
+        );
+        if (outcome.ok) return outcome.value;
+        return failWith(outcome.error);
+      };
+    }
+  });
+  const signalContext = entry.ownSignalPath ? new ExecutionContext({
+    layerPath: entry.ownSignalPath.slice(0, -1),
+    brickPath: [entry.ownSignalPath.at(-1) ?? entry.key],
+    callId: context.callId,
+    providers: context.providers,
+    ...context.signalHandlers ? { signalHandlers: context.signalHandlers } : {}
+  }) : context;
+  const signals = createSignalFunctions(signalContext);
+  return executeBrickImplementation(
+    implementation,
+    params,
+    context.providers,
+    dependencies,
+    signals
+  );
+}
+function executeBrick(options) {
+  const id = options.id ?? randomUUID();
+  const handlers = options.signals ?? {};
+  const boundary = options.directSignals ? directSignalChain(handlers) : createSignalHandlerChain(flattenNamespacedSignalHandlers(handlers), void 0, true);
+  const rootId = options.root.id?.split(".") ?? [];
+  const context = new ExecutionContext({
+    layerPath: rootId.slice(0, -1),
+    brickPath: rootId.length > 0 ? [rootId.at(-1)] : [],
+    callId: id,
+    providers: options.providers,
+    signalHandlers: boundary
+  });
+  const request = {
+    id,
+    ...options.root.id ? { brickId: options.root.id } : {},
+    params: options.params,
+    ...options.metadata ? { metadata: options.metadata } : {},
+    context,
+    execute: () => executeResolvedBrick(options.root, options.params, options, context),
+    signal: ({ name, request: signalRequest }) => resolveSignal(boundary, name, signalRequest)
+  };
+  return createBrickRun((options.worker ?? localWorker).start(request));
+}
+function createSuppliedEntry(key, brick2, dependencies, path) {
+  const id = [...path, key].join(".");
+  return Object.freeze({
+    id,
+    key,
+    implementation: brick2,
+    suppliedPath: Object.freeze([...path, key]),
+    ...dependencies ? { suppliedDependencies: dependencies } : {}
+  });
+}
+function runDirectBrick(implementation, params, options) {
+  const root = Object.freeze({
+    key: "direct",
+    implementation,
+    ...options?.dependencies ? { suppliedDependencies: options.dependencies } : {}
+  });
+  return executeBrick({
+    root,
+    entries: [root],
+    params,
+    providers: Object.freeze({ ...options?.requirements ?? {} }),
+    resolveDependency: (caller, alias) => {
+      const node = caller.suppliedDependencies?.[alias];
+      if (!node?.brick) throw new Error(`Missing direct dependency Brick "${alias}"`);
+      return createSuppliedEntry(alias, node.brick, node.dependencies, caller.id?.split(".") ?? []);
+    },
+    directSignals: true,
+    ...options?.signals ? { signals: options.signals } : {},
+    ...options?.worker ? { worker: options.worker } : {},
+    ...typeof options?.id === "string" ? { id: options.id } : {},
+    ...options?.metadata ? { metadata: options.metadata } : {}
+  });
+}
+
+// src/brick/contract.ts
+function brick(handler) {
+  const implementation = { handler };
+  Object.defineProperty(implementation, "run", {
+    configurable: false,
+    enumerable: false,
+    value: (params, ...options) => runDirectBrick(implementation, params, options[0]),
+    writable: false
+  });
+  markBrickImplementation(implementation);
+  return Object.freeze(implementation);
+}
+
+// src/layer/composition.ts
+function isLayer(value) {
+  return value instanceof LayerRuntime;
+}
+function flattenLayer(layer) {
+  const flattened = [];
+  const durableIds = /* @__PURE__ */ new Set();
+  const active = /* @__PURE__ */ new Set();
+  const visit = (current, parentPath) => {
+    const path = [...parentPath, current.id];
+    if (active.has(current)) {
+      throw new Error(`Cyclic Layer nesting detected: ${[...path, current.id].join(" -> ")}`);
+    }
+    active.add(current);
+    for (const [key, entry] of Object.entries(current.entries)) {
+      if (isBrickImplementation(entry)) {
+        const id = [...path, key].join(".");
+        if (durableIds.has(id)) {
+          throw new Error(`Duplicate durable Brick ID: ${id}`);
+        }
+        durableIds.add(id);
+        flattened.push(
+          Object.freeze({
+            id,
+            key,
+            layerPath: Object.freeze([...path]),
+            implementation: entry
+          })
+        );
+      } else if (isLayer(entry)) {
+        visit(entry, path);
+      } else {
+        throw new Error(`Invalid Layer entry at ${[...path, key].join(".")}`);
+      }
+    }
+    active.delete(current);
+  };
+  visit(layer, []);
+  return Object.freeze(flattened);
+}
+function findLayerDependency(layer, caller, alias, fallback) {
+  const entries = flattenLayer(layer);
+  const inCallerScope = entries.filter(
+    (entry) => entry.key === alias && entry.layerPath.join(".") === caller.layerPath.join(".")
+  );
+  if (inCallerScope.length > 0) return inCallerScope[0];
+  const matches = entries.filter((entry) => entry.key === alias);
+  if (matches.length === 0) return fallback;
+  if (matches.length > 1 && fallback) return fallback;
+  if (matches.length > 1) {
+    throw new Error(
+      `Ambiguous dependency Brick entry "${alias}" resolved to multiple durable paths: ${matches.map(({ id }) => id).join(", ")}`
+    );
+  }
+  return matches[0];
+}
+function effectiveLayerProviders(layer) {
+  const providers = /* @__PURE__ */ Object.create(null);
+  const sources = /* @__PURE__ */ new Map();
+  const topLevelKeys = new Set(Object.keys(layer.providers));
+  const visit = (current, path) => {
+    const currentPath = [...path, current.id];
+    for (const entry of Object.values(current.entries)) {
+      if (isLayer(entry)) visit(entry, currentPath);
+    }
+    for (const [key, value] of Object.entries(current.providers)) {
+      if (path.length === 0) {
+        providers[key] = value;
+        sources.set(key, currentPath.join("."));
+        continue;
+      }
+      if (topLevelKeys.has(key)) continue;
+      if (Object.hasOwn(providers, key) && providers[key] !== value) {
+        throw new Error(
+          `Conflicting nested Layer provider "${key}" from ${sources.get(key)} and ${currentPath.join(".")}`
+        );
+      }
+      providers[key] = value;
+      sources.set(key, currentPath.join("."));
+    }
+  };
+  visit(layer, []);
+  return Object.freeze(providers);
+}
+var LayerRuntime = class {
+};
+
+// src/layer/provide.ts
+function addProviders(current, values) {
+  for (const key of Object.keys(values)) {
+    if (Object.hasOwn(current, key)) {
+      throw new Error(`Provider key is already provided: ${key}`);
+    }
+  }
+  return Object.freeze({ ...current, ...values });
+}
+
+// src/layer/layer.ts
+function hasProviderKey(layer, key) {
+  if (Object.hasOwn(layer.providers, key)) return true;
+  return Object.values(layer.entries).some((entry) => isLayer(entry) && hasProviderKey(entry, key));
+}
+var reservedNames = /* @__PURE__ */ new Set([
+  "id",
+  "entries",
+  "providers",
+  "provide",
+  "override"
+]);
+var LayerImplementation = class _LayerImplementation extends LayerRuntime {
+  id;
+  entries;
+  providers;
+  constructor(id, entries, providers) {
+    super();
+    assertValidPathSegment(id);
+    for (const [key, entry] of Object.entries(entries)) {
+      assertValidPathSegment(key);
+      if (reservedNames.has(key)) {
+        throw new Error(`Reserved Layer entry name: ${key}`);
+      }
+      if (!isBrickImplementation(entry) && !isLayer(entry)) {
+        throw new Error(`Invalid Layer entry value for key: ${key}`);
+      }
+    }
+    this.id = id;
+    this.entries = Object.freeze({ ...entries });
+    this.providers = Object.freeze({ ...providers ?? {} });
+    for (const [key, entry] of Object.entries(this.entries)) {
+      Object.defineProperty(this, key, {
+        configurable: false,
+        enumerable: true,
+        value: this.bindEntry(entry, key),
+        writable: false
+      });
+    }
+    flattenLayer(this);
+    Object.freeze(this);
+  }
+  bindEntry(entry, key) {
+    if (isBrickImplementation(entry)) return this.bindBrick(entry, key, `${this.id}.${key}`);
+    if (isLayer(entry)) return this.bindNestedLayer(entry, `${this.id}.${entry.id}`);
+    return entry;
+  }
+  bindBrick(entry, key, targetId) {
+    const layer = this;
+    const bound = {
+      handler: entry.handler,
+      run(params, options) {
+        const entries = flattenLayer(layer);
+        const root = entries.find((candidate) => candidate.id === targetId);
+        if (!root) throw new Error(`Bound Brick entry not found: ${key}`);
+        const suppliedDependencies = options?.dependencies ?? {};
+        const executionRoot = Object.freeze({
+          ...root,
+          ...options?.dependencies ? { suppliedDependencies } : {}
+        });
+        return executeBrick({
+          root: executionRoot,
+          entries,
+          params,
+          providers: Object.freeze({
+            ...effectiveLayerProviders(layer),
+            ...options?.requirements ?? {}
+          }),
+          resolveDependency: (caller, alias) => {
+            const callerLayerPath = caller.layerPath ?? root.layerPath;
+            const suppliedNode = caller.suppliedDependencies?.[alias];
+            const supplied = suppliedNode?.brick ? suppliedNode : void 0;
+            const suppliedBranchPath = Object.freeze([...caller.suppliedPath ?? [], alias]);
+            const scopedSupplied = supplied ? Object.freeze({
+              id: [...caller.id?.split(".") ?? [], alias].join("."),
+              key: alias,
+              implementation: supplied.brick,
+              layerPath: Object.freeze([...callerLayerPath]),
+              suppliedPath: suppliedBranchPath,
+              ...supplied.dependencies ? { suppliedDependencies: supplied.dependencies } : {}
+            }) : void 0;
+            if (callerLayerPath.length > 0) {
+              const layerEntry = findLayerDependency(
+                layer,
+                caller,
+                alias,
+                scopedSupplied
+              );
+              if (layerEntry) {
+                const resolvedDependencies = suppliedNode?.dependencies ?? caller.suppliedDependencies?.[alias]?.dependencies;
+                return resolvedDependencies ? Object.freeze({
+                  ...layerEntry,
+                  suppliedDependencies: resolvedDependencies,
+                  signalPath: Object.freeze(layerEntry.id.split(".")),
+                  ...caller.suppliedPath || suppliedNode ? { suppliedPath: suppliedBranchPath } : {},
+                  ...scopedSupplied ? { ownSignalPath: scopedSupplied.suppliedPath } : {}
+                }) : scopedSupplied ? Object.freeze({
+                  ...layerEntry,
+                  suppliedPath: scopedSupplied.suppliedPath,
+                  signalPath: Object.freeze(layerEntry.id.split(".")),
+                  ownSignalPath: scopedSupplied.suppliedPath
+                }) : caller.suppliedPath ? Object.freeze({
+                  ...layerEntry,
+                  suppliedPath: caller.suppliedPath,
+                  signalPath: Object.freeze(layerEntry.id.split("."))
+                }) : layerEntry;
+              }
+            }
+            if (scopedSupplied) return scopedSupplied;
+            throw new Error(`Missing dependency Brick entry "${alias}" in the configured Layer`);
+          },
+          ...options?.signals ? { signals: options.signals } : {},
+          ...options?.worker ? { worker: options.worker } : {},
+          ...typeof options?.id === "string" ? { id: options.id } : {},
+          ...options?.metadata ? { metadata: options.metadata } : {}
+        });
+      }
+    };
+    markBrickImplementation(bound);
+    return Object.freeze(bound);
+  }
+  bindNestedLayer(nested, pathPrefix) {
+    const view = Object.create(Object.getPrototypeOf(nested));
+    Object.defineProperties(view, {
+      id: { enumerable: true, value: nested.id },
+      entries: { enumerable: false, value: nested.entries },
+      providers: { enumerable: false, value: nested.providers },
+      provide: { value: nested.provide?.bind(nested) },
+      override: { value: nested.override?.bind(nested) }
+    });
+    for (const [key, entry] of Object.entries(nested.entries)) {
+      Object.defineProperty(view, key, {
+        enumerable: true,
+        value: isBrickImplementation(entry) ? this.bindBrick(entry, key, `${pathPrefix}.${key}`) : isLayer(entry) ? this.bindNestedLayer(entry, `${pathPrefix}.${entry.id}`) : entry
+      });
+    }
+    return Object.freeze(view);
+  }
+  provide(values) {
+    addProviders(effectiveLayerProviders(this), values);
+    return new _LayerImplementation(this.id, this.entries, { ...this.providers, ...values });
+  }
+  override(values) {
+    for (const key of Object.keys(values)) {
+      if (!hasProviderKey(this, key)) {
+        throw new Error(`Cannot override absent provider key: ${key}`);
+      }
+    }
+    return new _LayerImplementation(this.id, this.entries, { ...this.providers, ...values });
+  }
+};
+var Layer = LayerImplementation;
+export {
+  DuplicateLocalRunIdError,
+  ExecutionContext,
+  Layer,
+  LocalRunCancelledError,
+  LocalWorker,
+  MissingSignalHandlerError,
+  NonBoundarySignalHandlerChainError,
+  P,
+  UnhandledBrickFailureError,
+  brick,
+  localWorker
+};
+//# sourceMappingURL=index.js.map