@smthrs/harness 0.0.0-stage → 1.0.0-rc.3

package/dist/cjs/FlowBinding.d.ts

@@ -0,0 +1,289 @@
+/**
+ * The executable-flow binding contract.
+ *
+ * A cell's only authority is `ctx.call(flow, input)`, so *every* capability an
+ * agent can reach — a standard filesystem flow, a memory flow, an incoming MCP
+ * tool, a durable child agent — has to arrive as an ordinary flow declaration
+ * plus the code that runs it. This module is the smallest contract that pairs
+ * the two.
+ *
+ * Three types carry the whole idea:
+ *
+ * - a {@link Binding} is one flow declaration, its projected
+ *   `Descriptor.FlowDescriptor`, and a runner that decodes cell input through
+ *   the flow's input schema, executes the handler, and validates the handler's
+ *   output back into serializable JSON;
+ * - a {@link Source} produces bindings, possibly effectfully, so a lazily
+ *   connected server or a plugin can contribute without being resolved at
+ *   import time;
+ * - a {@link Catalog} is the deterministic composition of sources, and it
+ *   refuses duplicate executable names rather than letting one descriptor be
+ *   dispatched to another implementation.
+ *
+ * This is deliberately *not* a second registry. The descriptors a catalog
+ * projects are ordinary `FlowDescriptor`s, and {@link registry} composes them
+ * onto an existing `Registry.Registry` behind that same contract — with the
+ * file-discovered entries winning, so discovery precedence is untouched.
+ *
+ * The failure split is the one `EngineLike.call` declares. A refusal the agent
+ * could plausibly correct — malformed input, a flow that failed, output that is
+ * not serializable — becomes a `failure` {@link Cell.CallResult} the cell
+ * observes as a resolved `{ ok: false, error }` envelope. The cell branches on
+ * `.ok === false` and `.error.code` to recover; ordinary failures do not throw.
+ * Anything the cell must never swallow, such as a permission requirement, an
+ * abort, or a suspension, stays in the typed error channel. An interruption
+ * is never caught at all.
+ *
+ * Governing design: `../docs/concepts.md#durable-cell-loop` and
+ * `../docs/concepts.md#flow-registry`.
+ *
+ * @since 0.1.0
+ */
+import type * as Effects from "@smthrs/core/Effects";
+import * as Descriptor from "@smthrs/registry/Descriptor";
+import * as Registry from "@smthrs/registry/Registry";
+import type { Context, Schema as SchemaTypes } from "effect";
+import { Effect, Option, Result, Schema } from "effect";
+import type * as Cell from "./Cell.ts";
+import { CallResult } from "./Cell.ts";
+import { HarnessError } from "./HarnessError.ts";
+/**
+ * The declaration half of a binding.
+ *
+ * Schema and metadata record accepted by bindings and registry admission.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export interface Declared {
+    readonly name?: string | undefined;
+    readonly description?: string | undefined;
+    readonly input?: SchemaTypes.Top | undefined;
+    readonly output?: SchemaTypes.Top | undefined;
+    readonly flows?: ReadonlyArray<string> | undefined;
+    readonly model?: string | ReadonlyArray<string> | undefined;
+    readonly annotations?: Context.Context<never> | undefined;
+    readonly budget?: Descriptor.FlowBudget | undefined;
+    readonly deadline?: number | undefined;
+    readonly modelInvocable?: boolean | undefined;
+    readonly disableModelInvocation?: boolean | undefined;
+    readonly capabilities: ReadonlyArray<string>;
+    readonly effects: Effects.Declaration | undefined;
+}
+/**
+ * The metadata a projected descriptor needs that a flow declaration does not
+ * carry.
+ *
+ * Every default is the conservative one: a binding is model-invocable, has no
+ * placement, and is attributed to the `binding` source.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export interface DescriptorOptions {
+    /** Overrides the declaration's own name. */
+    readonly name?: string | undefined;
+    /** The stable locator recorded as the descriptor's body and path. */
+    readonly path?: string | undefined;
+    /**
+     * Content identity of the executable body. `make` derives this from the
+     * handler when omitted; direct descriptor projections derive it from the
+     * declaration they can observe.
+     */
+    readonly bodyDigest?: string | undefined;
+    readonly modelInvocable?: boolean | undefined;
+    readonly placement?: Option.Option<Descriptor.Placement> | undefined;
+    readonly provenance?: Descriptor.Provenance | undefined;
+    /**
+     * The input schema as a JSON Schema document, carried by value.
+     *
+     * A binding holds the real schema, so recording a `binding://` locator
+     * throws away the one description of the call's shape anything downstream
+     * could read. {@link make} fills this in, which is what puts a parameter
+     * schema beside every flow in `ctx.flows`.
+     */
+    readonly inputDocument?: Schema.Json | undefined;
+    /** The output schema as a JSON Schema document, carried by value. */
+    readonly outputDocument?: Schema.Json | undefined;
+    /**
+     * What a call to this flow does, for a reader of a run.
+     *
+     * Absent means unknown, and unknown stays unknown: a reader that is given
+     * nothing says nothing rather than guessing from the flow's name. `bash` is
+     * the deliberate absence — what a shell call does is in the command.
+     */
+    readonly activity?: Descriptor.FlowActivity | undefined;
+    /**
+     * How one recorded call to this flow reads.
+     *
+     * This is the one authority a run card has for the words beside a call. It
+     * grants nothing: {@link Descriptor.declarationDigest} and
+     * {@link Descriptor.executionDigest} both exclude it, so declaring it cannot
+     * invalidate a reviewed plan, a call identity, or a cached prompt.
+     */
+    readonly presentation?: Descriptor.CallPresentation | undefined;
+}
+/**
+ * Projects an ordinary flow declaration into a registry descriptor.
+ *
+ * @category conversions
+ * @since 0.1.0
+ * @slop
+ */
+export declare const descriptorOf: (declaration: Declared, options?: DescriptorOptions) => Descriptor.FlowDescriptor;
+/**
+ * One flow declaration and the code that runs it.
+ *
+ * `R` is whatever the handler still needs from the host. A catalog only accepts
+ * fully supplied bindings, so a host uses {@link provide} to close `R` with the
+ * context it built.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export interface Binding<R = never> {
+    readonly descriptor: Descriptor.FlowDescriptor;
+    readonly run: (call: Cell.Call) => Effect.Effect<CallResult, HarnessError, R>;
+}
+/**
+ * Everything one executable binding declares.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export interface Options<I extends SchemaTypes.Top & SchemaTypes.ConstraintDecoder<unknown, never>, O extends SchemaTypes.Top & SchemaTypes.ConstraintEncoder<unknown, never>, E, R> extends DescriptorOptions {
+    /** The ordinary flow declaration. Its schemas are the call's contract. */
+    readonly flow: {
+        readonly input: I;
+        readonly output: O;
+    } & Declared;
+    /**
+     * The runtime implementation, with whatever requirements the host supplies.
+     *
+     * The decoded input is the whole contract for an ordinary capability. The
+     * call is passed as well because a handler that opens a *durable* boundary of
+     * its own — a timer, a child run — needs a replay-stable name for it, and
+     * `call.identity` is exactly that name: re-executing the cell reaches the
+     * same ordinal with the same declaration.
+     */
+    readonly handler: (input: I["Type"], call: Cell.Call) => Effect.Effect<O["Type"], E, R>;
+    /**
+     * Opts safe handler-failure details into cell-visible, journaled text.
+     * Forward message only for error classes the host authored with model-facing
+     * text; never forward messages of transport, SDK, OS, or unknown errors,
+     * headers, URLs, or serialized causes.
+     * Undefined or a thrown renderer uses the opaque default. Permission errors
+     * and existing HarnessErrors bypass this renderer and stay in the error channel.
+     * Inspect raw causes in the host handler, redacting before any persistence.
+     */
+    readonly publicError?: ((error: E) => string | undefined) | undefined;
+    /**
+     * Whether a handler failure is the flow's own timeout (a command past its
+     * limit, or a wait that gave up), and the limit in milliseconds it ran past
+     * when the failure says. Undefined for any other failure. The cell reads a
+     * timeout as a `timeout` call failure, the code of the call boundary's own
+     * limit, and a host that guards timeouts parks the run on it with this
+     * limit. Absent, every failure is `flow_failed`.
+     */
+    readonly timedOut?: ((error: E) => {
+        readonly limitMillis?: number | undefined;
+    } | undefined) | undefined;
+}
+/**
+ * Binds one flow declaration to its runtime implementation.
+ *
+ * @category constructors
+ * @since 0.1.0
+ * @slop
+ */
+export declare const make: <I extends SchemaTypes.Top & SchemaTypes.ConstraintDecoder<unknown, never>, O extends SchemaTypes.Top & SchemaTypes.ConstraintEncoder<unknown, never>, E, R = never>(options: Options<I, O, E, R>) => Binding<R>;
+/**
+ * Supplies a binding's remaining requirements from a context the host built.
+ *
+ * @category combinators
+ * @since 0.1.0
+ * @slop
+ */
+export declare const provide: <R, R2>(self: Binding<R>, services: Context.Context<R2>) => Binding<Exclude<R, R2>>;
+/**
+ * A named producer of executable bindings.
+ *
+ * Producing bindings is an effect so a source may connect a server, read a
+ * manifest, or resolve a credential the first time a host composes it — the
+ * lazy lifecycle an incoming MCP wrapper needs, expressed once here instead of
+ * as a special case in the controller.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export interface Source {
+    readonly name: string;
+    readonly bindings: () => Effect.Effect<ReadonlyArray<Binding>, HarnessError>;
+}
+/**
+ * Constructs a source over a fixed binding list.
+ *
+ * @category constructors
+ * @since 0.1.0
+ * @slop
+ */
+export declare const source: (name: string, bindings: ReadonlyArray<Binding>) => Source;
+/**
+ * The deterministic composition of every executable binding a host resolved.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export interface Catalog {
+    /** Bindings in composition order. */
+    readonly entries: ReadonlyArray<Binding>;
+    /** The same bindings, keyed by flow name. */
+    readonly bindings: ReadonlyMap<string, Binding>;
+    /** The descriptors those bindings project, in composition order. */
+    readonly descriptors: ReadonlyArray<Descriptor.FlowDescriptor>;
+}
+/**
+ * The empty catalog.
+ *
+ * @category constructors
+ * @since 0.1.0
+ * @slop
+ */
+export declare const empty: () => Catalog;
+/**
+ * Composes bindings into a catalog, refusing duplicate names.
+ *
+ * @category constructors
+ * @since 0.1.0
+ * @slop
+ */
+export declare const catalogResult: (bindings: ReadonlyArray<Binding>) => Result.Result<Catalog, HarnessError>;
+/**
+ * Resolves ordered sources into one catalog.
+ *
+ * @category constructors
+ * @since 0.1.0
+ * @slop
+ */
+export declare const catalog: (sources: ReadonlyArray<Source>) => Effect.Effect<Catalog, HarnessError>;
+/**
+ * Discloses a catalog's descriptors through an existing registry.
+ *
+ * File-discovered entries win: a binding whose name a source already discovered
+ * is not disclosed, which is what keeps `flow.ts > flow.mdx > SKILL.md`
+ * precedence exactly where discovery put it. The shadowed binding is reported
+ * as an ordinary `duplicate_name` warning rather than silently dispatched, and
+ * the resolver refuses the shadowed name with a resolved failure envelope.
+ *
+ * @category constructors
+ * @since 0.1.0
+ * @slop
+ */
+export declare const registry: (base: Registry.Registry, self: Catalog) => Registry.Registry;
+//# sourceMappingURL=FlowBinding.d.ts.map

package/dist/cjs/FlowBinding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowBinding.d.ts","sourceRoot":"","sources":["../../src/FlowBinding.ts"],"names":[],"mappings":"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"}

package/dist/cjs/FlowBinding.js

@@ -0,0 +1,251 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var FlowBinding_exports = {};
+__export(FlowBinding_exports, {
+  catalog: () => catalog,
+  catalogResult: () => catalogResult,
+  descriptorOf: () => descriptorOf,
+  empty: () => empty,
+  make: () => make,
+  provide: () => provide,
+  registry: () => registry,
+  source: () => source
+});
+module.exports = __toCommonJS(FlowBinding_exports);
+var Permission = __toESM(require("@smthrs/capability/Permission"), 1);
+var Digest = __toESM(require("@smthrs/core/Digest"), 1);
+var Descriptor = __toESM(require("@smthrs/registry/Descriptor"), 1);
+var Registry = __toESM(require("@smthrs/registry/Registry"), 1);
+var import_effect = require("effect");
+var import_CallLedger = require("./CallLedger.js");
+var import_Cell = require("./Cell.js");
+var import_HarnessError = require("./HarnessError.js");
+var elide = __toESM(require("./internal/elide.js"), 1);
+var import_refusal = require("./internal/refusal.js");
+const declaredEffects = (effects) => ({
+  reads: effects?.reads ?? [],
+  writes: effects?.writes ?? [],
+  mode: effects?.mode ?? "expected",
+  onConflict: effects?.onConflict ?? "serialize",
+  tier: effects?.tier ?? "irreversible"
+});
+const omittableNullKeys = (schema) => {
+  const ast = import_effect.SchemaAST.toEncoded(schema.ast);
+  if (ast._tag !== "Objects") return /* @__PURE__ */ new Set();
+  return new Set(
+    ast.propertySignatures.filter((field) => import_effect.SchemaAST.isOptional(field.type) && !import_effect.Schema.is(import_effect.Schema.make(field.type))(null)).map((field) => field.name)
+  );
+};
+const withoutRejectedNulls = (input, keys) => {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) return input;
+  return Object.fromEntries(Object.entries(input).filter(([key, value]) => value !== null || !keys.has(key)));
+};
+const document = (schema) => {
+  try {
+    return JSON.parse(JSON.stringify(import_effect.Schema.toJsonSchemaDocument(schema, { onExcessProperty: "error" })));
+  } catch {
+    return void 0;
+  }
+};
+const descriptorOf = (declaration, options = {}) => {
+  const name = options.name ?? declaration.name ?? "";
+  const path = options.path ?? `binding://${name}`;
+  const bodyDigest = options.bodyDigest ?? Digest.digest(Digest.canonical({
+    capabilities: declaration.capabilities,
+    description: declaration.description ?? "",
+    effects: declaration.effects ?? null,
+    name
+  }));
+  return new Descriptor.FlowDescriptor({
+    name,
+    description: declaration.description ?? "",
+    body: new Descriptor.BodyRefModule({ path, contentDigest: bodyDigest }),
+    input: options.inputDocument === void 0 ? new Descriptor.SchemaRefModule({ path, field: "input" }) : new Descriptor.SchemaRefInline({ document: options.inputDocument }),
+    output: options.outputDocument === void 0 ? new Descriptor.SchemaRefModule({ path, field: "output" }) : new Descriptor.SchemaRefInline({ document: options.outputDocument }),
+    model: import_effect.Option.none(),
+    flows: [],
+    capabilities: declaration.capabilities,
+    effects: declaredEffects(declaration.effects),
+    placement: options.placement ?? import_effect.Option.none(),
+    modelInvocable: options.modelInvocable ?? true,
+    // Omitted rather than carried as `undefined`: an absent display field is
+    // the absence of the claim, and `Descriptor.FlowDescriptor` encodes an
+    // omitted optional field away instead of writing a null nobody declared.
+    ...options.activity === void 0 ? {} : { activity: options.activity },
+    ...options.presentation === void 0 ? {} : { presentation: options.presentation },
+    path,
+    frontmatter: {},
+    provenance: options.provenance ?? new Descriptor.Provenance({ source: "binding", root: "binding://" })
+  });
+};
+const describeFailure = (error) => elide.head(error.message, import_CallLedger.width * 4, "reissue the call to see the whole failure");
+const publicMessage = (error, render) => {
+  try {
+    const message = render?.(error);
+    return typeof message === "string" ? elide.head(message, import_CallLedger.width * 4, "ask the host for the full public failure") : void 0;
+  } catch {
+    return void 0;
+  }
+};
+const escalated = (error) => {
+  if (error instanceof import_HarnessError.HarnessError) return error;
+  if (error instanceof Permission.PermissionRequired) {
+    return new import_HarnessError.HarnessError({ code: "suspended", message: error.message, cause: error });
+  }
+  if (error instanceof Permission.PermissionDenied) {
+    return new import_HarnessError.HarnessError({ code: "suspended", message: error.message, cause: error });
+  }
+  return void 0;
+};
+const make = (options) => {
+  const descriptor = descriptorOf({ ...options.flow, capabilities: [...new Set(options.flow.capabilities)].sort() }, {
+    ...options,
+    bodyDigest: options.bodyDigest ?? Digest.digest(Function.prototype.toString.call(options.handler)),
+    ...options.inputDocument === void 0 ? { inputDocument: document(options.flow.input) } : {},
+    ...options.outputDocument === void 0 ? { outputDocument: document(options.flow.output) } : {}
+  });
+  const decodeInput = import_effect.Schema.decodeUnknownResult(options.flow.input);
+  const nullKeys = omittableNullKeys(options.flow.input);
+  const decodeCall = (input) => {
+    const first = decodeInput(input);
+    if (first._tag !== "Failure") return first;
+    const retried = decodeInput(input === null ? {} : withoutRejectedNulls(input, nullKeys));
+    return retried._tag === "Failure" ? first : retried;
+  };
+  const encodeOutput = import_effect.Schema.encodeUnknownResult(options.flow.output);
+  const asJson = import_effect.Schema.decodeUnknownResult(import_effect.Schema.Json);
+  return {
+    descriptor,
+    run: (call) => import_effect.Effect.gen(function* () {
+      const decoded = decodeCall(call.input);
+      if (decoded._tag === "Failure") {
+        return (0, import_refusal.refusal)(
+          "invalid_input",
+          `Flow ${descriptor.name} rejected its input: ${describeFailure(decoded.failure)}. Re-read ctx.flows and reissue the call.`
+        );
+      }
+      const produced = yield* import_effect.Effect.result(options.handler(decoded.success, call));
+      if (produced._tag === "Failure") {
+        const escalate = escalated(produced.failure);
+        if (escalate !== void 0) return yield* import_effect.Effect.fail(escalate);
+        const message = publicMessage(produced.failure, options.publicError);
+        const rendered = message === void 0 ? `Flow ${descriptor.name} failed.` : `Flow ${descriptor.name} failed: ${message}`;
+        const timeout = options.timedOut?.(produced.failure);
+        return timeout === void 0 ? (0, import_refusal.refusal)("flow_failed", rendered) : timeout.limitMillis === void 0 ? (0, import_refusal.refusal)("timeout", rendered) : (0, import_refusal.timedOut)(rendered, timeout.limitMillis);
+      }
+      const encoded = encodeOutput(produced.success);
+      if (encoded._tag === "Failure") {
+        return (0, import_refusal.refusal)("flow_failed", `Flow ${descriptor.name} produced output its own schema rejects.`);
+      }
+      const json = asJson(encoded.success);
+      if (json._tag === "Failure") {
+        return (0, import_refusal.refusal)("flow_failed", `Flow ${descriptor.name} produced output that is not serializable.`);
+      }
+      return new import_Cell.CallResult({ outcome: "success", value: json.success });
+    })
+  };
+};
+const provide = (self, services) => ({
+  descriptor: self.descriptor,
+  run: (call) => import_effect.Effect.provide(self.run(call), services)
+});
+const source = (name, bindings) => ({
+  name,
+  bindings: () => import_effect.Effect.succeed(bindings)
+});
+const emptyCatalog = { entries: [], bindings: /* @__PURE__ */ new Map(), descriptors: [] };
+const empty = () => emptyCatalog;
+const duplicate = (name) => new import_HarnessError.HarnessError({
+  code: "assembly_failed",
+  message: `Two executable bindings are named "${name}". A flow name resolves to exactly one implementation; rename one or drop it before composing the host.`
+});
+const unnamed = () => new import_HarnessError.HarnessError({
+  code: "assembly_failed",
+  message: "An executable binding has no flow name. Give the declaration a name, or pass one to FlowBinding.make."
+});
+const catalogResult = (bindings) => {
+  const composed = /* @__PURE__ */ new Map();
+  const descriptors = [];
+  for (const binding of bindings) {
+    const name = binding.descriptor.name;
+    if (name.length === 0) return import_effect.Result.fail(unnamed());
+    if (composed.has(name)) return import_effect.Result.fail(duplicate(name));
+    composed.set(name, binding);
+    descriptors.push(binding.descriptor);
+  }
+  return import_effect.Result.succeed({
+    entries: Object.freeze([...bindings]),
+    bindings: composed,
+    descriptors: Object.freeze(descriptors)
+  });
+};
+const catalog = (sources) => import_effect.Effect.gen(function* () {
+  const collected = [];
+  for (const entry of sources) {
+    collected.push(...yield* entry.bindings());
+  }
+  return yield* import_effect.Effect.fromResult(catalogResult(collected));
+});
+const registry = (base, self) => {
+  const added = (entries) => {
+    const discovered = new Set(entries.map((entry) => entry.name));
+    return self.descriptors.filter((entry) => !discovered.has(entry.name));
+  };
+  const list = () => import_effect.Effect.map(base.list(), (entries) => [...entries, ...added(entries)]);
+  const visible = () => import_effect.Effect.gen(function* () {
+    const shown = yield* base.visible();
+    const discovered = yield* base.list();
+    return [...shown, ...added(discovered).filter((entry) => entry.modelInvocable)];
+  });
+  const getOption = (name) => import_effect.Effect.flatMap(base.getOption(name), (found) => import_effect.Option.isSome(found) ? import_effect.Effect.succeed(found) : import_effect.Effect.map(base.list(), (entries) => entries.some((entry) => entry.name === name) ? import_effect.Option.none() : import_effect.Option.fromUndefinedOr(self.bindings.get(name)?.descriptor)));
+  return Registry.makeNoop({
+    list,
+    visible,
+    getOption,
+    get: (name) => import_effect.Effect.flatMap(getOption(name), (found) => import_effect.Option.isSome(found) ? import_effect.Effect.succeed(found.value) : base.get(name)),
+    loadBody: base.loadBody,
+    runPrompt: base.runPrompt,
+    refresh: base.refresh,
+    warnings: () => import_effect.Effect.gen(function* () {
+      const declared = yield* base.warnings();
+      const entries = yield* base.list();
+      const discovered = new Set(entries.map((entry) => entry.name));
+      const shadowed = self.descriptors.filter((entry) => discovered.has(entry.name)).map(
+        (entry) => new Descriptor.DiscoveryWarning({
+          code: "duplicate_name",
+          path: entry.path,
+          name: entry.name,
+          message: `Executable binding "${entry.name}" is shadowed by a discovered flow; the discovered entry keeps the name.`
+        })
+      );
+      return [...declared, ...shadowed];
+    })
+  });
+};
+//# sourceMappingURL=FlowBinding.js.map

package/dist/cjs/FlowBinding.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/FlowBinding.ts"],
+  "sourcesContent": ["/**\n * The executable-flow binding contract.\n *\n * A cell's only authority is `ctx.call(flow, input)`, so *every* capability an\n * agent can reach \u2014 a standard filesystem flow, a memory flow, an incoming MCP\n * tool, a durable child agent \u2014 has to arrive as an ordinary flow declaration\n * plus the code that runs it. This module is the smallest contract that pairs\n * the two.\n *\n * Three types carry the whole idea:\n *\n * - a {@link Binding} is one flow declaration, its projected\n *   `Descriptor.FlowDescriptor`, and a runner that decodes cell input through\n *   the flow's input schema, executes the handler, and validates the handler's\n *   output back into serializable JSON;\n * - a {@link Source} produces bindings, possibly effectfully, so a lazily\n *   connected server or a plugin can contribute without being resolved at\n *   import time;\n * - a {@link Catalog} is the deterministic composition of sources, and it\n *   refuses duplicate executable names rather than letting one descriptor be\n *   dispatched to another implementation.\n *\n * This is deliberately *not* a second registry. The descriptors a catalog\n * projects are ordinary `FlowDescriptor`s, and {@link registry} composes them\n * onto an existing `Registry.Registry` behind that same contract \u2014 with the\n * file-discovered entries winning, so discovery precedence is untouched.\n *\n * The failure split is the one `EngineLike.call` declares. A refusal the agent\n * could plausibly correct \u2014 malformed input, a flow that failed, output that is\n * not serializable \u2014 becomes a `failure` {@link Cell.CallResult} the cell\n * observes as a resolved `{ ok: false, error }` envelope. The cell branches on\n * `.ok === false` and `.error.code` to recover; ordinary failures do not throw.\n * Anything the cell must never swallow, such as a permission requirement, an\n * abort, or a suspension, stays in the typed error channel. An interruption\n * is never caught at all.\n *\n * Governing design: `../docs/concepts.md#durable-cell-loop` and\n * `../docs/concepts.md#flow-registry`.\n *\n * @since 0.1.0\n */\n\nimport * as Permission from \"@smthrs/capability/Permission\"\nimport * as Digest from \"@smthrs/core/Digest\"\nimport type * as Effects from \"@smthrs/core/Effects\"\nimport * as Descriptor from \"@smthrs/registry/Descriptor\"\nimport * as Registry from \"@smthrs/registry/Registry\"\nimport type { Context, Schema as SchemaTypes } from \"effect\"\nimport { Effect, Option, Result, Schema, SchemaAST } from \"effect\"\nimport { width as callLedgerWidth } from \"./CallLedger.ts\"\nimport type * as Cell from \"./Cell.ts\"\nimport { CallResult } from \"./Cell.ts\"\nimport { HarnessError } from \"./HarnessError.ts\"\nimport * as elide from \"./internal/elide.ts\"\nimport { refusal, timedOut } from \"./internal/refusal.ts\"\n\n/**\n * The declaration half of a binding.\n *\n * Schema and metadata record accepted by bindings and registry admission.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface Declared {\n  readonly name?: string | undefined\n  readonly description?: string | undefined\n  readonly input?: SchemaTypes.Top | undefined\n  readonly output?: SchemaTypes.Top | undefined\n  readonly flows?: ReadonlyArray<string> | undefined\n  readonly model?: string | ReadonlyArray<string> | undefined\n  readonly annotations?: Context.Context<never> | undefined\n  readonly budget?: Descriptor.FlowBudget | undefined\n  readonly deadline?: number | undefined\n  readonly modelInvocable?: boolean | undefined\n  readonly disableModelInvocation?: boolean | undefined\n  readonly capabilities: ReadonlyArray<string>\n  readonly effects: Effects.Declaration | undefined\n}\n\n/**\n * The metadata a projected descriptor needs that a flow declaration does not\n * carry.\n *\n * Every default is the conservative one: a binding is model-invocable, has no\n * placement, and is attributed to the `binding` source.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface DescriptorOptions {\n  /** Overrides the declaration's own name. */\n  readonly name?: string | undefined\n  /** The stable locator recorded as the descriptor's body and path. */\n  readonly path?: string | undefined\n  /**\n   * Content identity of the executable body. `make` derives this from the\n   * handler when omitted; direct descriptor projections derive it from the\n   * declaration they can observe.\n   */\n  readonly bodyDigest?: string | undefined\n  readonly modelInvocable?: boolean | undefined\n  readonly placement?: Option.Option<Descriptor.Placement> | undefined\n  readonly provenance?: Descriptor.Provenance | undefined\n  /**\n   * The input schema as a JSON Schema document, carried by value.\n   *\n   * A binding holds the real schema, so recording a `binding://` locator\n   * throws away the one description of the call's shape anything downstream\n   * could read. {@link make} fills this in, which is what puts a parameter\n   * schema beside every flow in `ctx.flows`.\n   */\n  readonly inputDocument?: Schema.Json | undefined\n  /** The output schema as a JSON Schema document, carried by value. */\n  readonly outputDocument?: Schema.Json | undefined\n  /**\n   * What a call to this flow does, for a reader of a run.\n   *\n   * Absent means unknown, and unknown stays unknown: a reader that is given\n   * nothing says nothing rather than guessing from the flow's name. `bash` is\n   * the deliberate absence \u2014 what a shell call does is in the command.\n   */\n  readonly activity?: Descriptor.FlowActivity | undefined\n  /**\n   * How one recorded call to this flow reads.\n   *\n   * This is the one authority a run card has for the words beside a call. It\n   * grants nothing: {@link Descriptor.declarationDigest} and\n   * {@link Descriptor.executionDigest} both exclude it, so declaring it cannot\n   * invalidate a reviewed plan, a call identity, or a cached prompt.\n   */\n  readonly presentation?: Descriptor.CallPresentation | undefined\n}\n\n/**\n * The conservative effect declaration used when a flow declares none.\n *\n * `irreversible` is the safe default: it is never content-shared across\n * executions, so a binding that forgot to declare its tier can never replay\n * another run's recorded result.\n */\nconst declaredEffects = (effects: Effects.Declaration | undefined): Descriptor.EffectDeclaration => ({\n  reads: effects?.reads ?? [],\n  writes: effects?.writes ?? [],\n  mode: effects?.mode ?? \"expected\",\n  onConflict: effects?.onConflict ?? \"serialize\",\n  tier: effects?.tier ?? \"irreversible\"\n})\n\n/** Only declared optional input properties that reject null can be omitted. */\nconst omittableNullKeys = (schema: SchemaTypes.Top): ReadonlySet<PropertyKey> => {\n  const ast = SchemaAST.toEncoded(schema.ast)\n  if (ast._tag !== \"Objects\") return new Set()\n  return new Set(\n    ast.propertySignatures\n      .filter((field) => SchemaAST.isOptional(field.type) && !Schema.is(Schema.make(field.type))(null))\n      .map((field) => field.name)\n  )\n}\n\n/** The JSON omission retry is limited to known top-level optional properties. */\nconst withoutRejectedNulls = (input: unknown, keys: ReadonlySet<PropertyKey>): unknown => {\n  if (typeof input !== \"object\" || input === null || Array.isArray(input)) return input\n  return Object.fromEntries(Object.entries(input).filter(([key, value]) => value !== null || !keys.has(key)))\n}\n\n/**\n * Renders one schema as a JSON Schema document, or `undefined` when it has no\n * JSON Schema form.\n *\n * A schema that cannot be projected is not an error: the descriptor falls\n * back to the locator it always recorded, and only the catalog rendering is\n * poorer for it.\n */\nconst document = (schema: SchemaTypes.Top): Schema.Json | undefined => {\n  try {\n    return JSON.parse(JSON.stringify(Schema.toJsonSchemaDocument(schema, { onExcessProperty: \"error\" }))) as Schema.Json\n  } catch {\n    return undefined\n  }\n}\n\n/**\n * Projects an ordinary flow declaration into a registry descriptor.\n *\n * @category conversions\n * @since 0.1.0\n * @slop\n */\nexport const descriptorOf = (\n  declaration: Declared,\n  options: DescriptorOptions = {}\n): Descriptor.FlowDescriptor => {\n  const name = options.name ?? declaration.name ?? \"\"\n  const path = options.path ?? `binding://${name}`\n  const bodyDigest = options.bodyDigest ?? Digest.digest(Digest.canonical({\n    capabilities: declaration.capabilities,\n    description: declaration.description ?? \"\",\n    effects: declaration.effects ?? null,\n    name\n  }))\n  return new Descriptor.FlowDescriptor({\n    name,\n    description: declaration.description ?? \"\",\n    body: new Descriptor.BodyRefModule({ path, contentDigest: bodyDigest }),\n    input: options.inputDocument === undefined\n      ? new Descriptor.SchemaRefModule({ path, field: \"input\" })\n      : new Descriptor.SchemaRefInline({ document: options.inputDocument }),\n    output: options.outputDocument === undefined\n      ? new Descriptor.SchemaRefModule({ path, field: \"output\" })\n      : new Descriptor.SchemaRefInline({ document: options.outputDocument }),\n    model: Option.none(),\n    flows: [],\n    capabilities: declaration.capabilities,\n    effects: declaredEffects(declaration.effects),\n    placement: options.placement ?? Option.none(),\n    modelInvocable: options.modelInvocable ?? true,\n    // Omitted rather than carried as `undefined`: an absent display field is\n    // the absence of the claim, and `Descriptor.FlowDescriptor` encodes an\n    // omitted optional field away instead of writing a null nobody declared.\n    ...(options.activity === undefined ? {} : { activity: options.activity }),\n    ...(options.presentation === undefined ? {} : { presentation: options.presentation }),\n    path,\n    frontmatter: {},\n    provenance: options.provenance ?? new Descriptor.Provenance({ source: \"binding\", root: \"binding://\" })\n  })\n}\n\n/**\n * One flow declaration and the code that runs it.\n *\n * `R` is whatever the handler still needs from the host. A catalog only accepts\n * fully supplied bindings, so a host uses {@link provide} to close `R` with the\n * context it built.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface Binding<R = never> {\n  readonly descriptor: Descriptor.FlowDescriptor\n  readonly run: (call: Cell.Call) => Effect.Effect<CallResult, HarnessError, R>\n}\n\n/** Bounds a schema rejection before it enters the journal and later frames. */\nconst describeFailure = (error: Schema.SchemaError): string =>\n  elide.head(error.message, callLedgerWidth * 4, \"reissue the call to see the whole failure\")\n\n/** Only explicitly public text may cross the host boundary. Renderer failures stay opaque too. */\nconst publicMessage = <E>(error: E, render: ((error: E) => string | undefined) | undefined): string | undefined => {\n  try {\n    const message = render?.(error)\n    return typeof message === \"string\"\n      ? elide.head(message, callLedgerWidth * 4, \"ask the host for the full public failure\")\n      : undefined\n  } catch {\n    return undefined\n  }\n}\n\n/**\n * Decides whether a handler failure is the cell's business.\n *\n * A permission requirement, a denial, and every harness-level failure are the\n * controller's to act on: parking, escalating, or aborting the run. Returning\n * them as call results would let a cell ignore its own permission park and\n * proceed as though it had authority.\n */\nconst escalated = (error: unknown): HarnessError | undefined => {\n  if (error instanceof HarnessError) return error\n  if (error instanceof Permission.PermissionRequired) {\n    return new HarnessError({ code: \"suspended\", message: error.message, cause: error })\n  }\n  if (error instanceof Permission.PermissionDenied) {\n    return new HarnessError({ code: \"suspended\", message: error.message, cause: error })\n  }\n  return undefined\n}\n\n/**\n * Everything one executable binding declares.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface Options<\n  I extends SchemaTypes.Top & SchemaTypes.ConstraintDecoder<unknown, never>,\n  O extends SchemaTypes.Top & SchemaTypes.ConstraintEncoder<unknown, never>,\n  E,\n  R\n> extends DescriptorOptions {\n  /** The ordinary flow declaration. Its schemas are the call's contract. */\n  readonly flow: {\n    readonly input: I\n    readonly output: O\n  } & Declared\n  /**\n   * The runtime implementation, with whatever requirements the host supplies.\n   *\n   * The decoded input is the whole contract for an ordinary capability. The\n   * call is passed as well because a handler that opens a *durable* boundary of\n   * its own \u2014 a timer, a child run \u2014 needs a replay-stable name for it, and\n   * `call.identity` is exactly that name: re-executing the cell reaches the\n   * same ordinal with the same declaration.\n   */\n  readonly handler: (input: I[\"Type\"], call: Cell.Call) => Effect.Effect<O[\"Type\"], E, R>\n  /**\n   * Opts safe handler-failure details into cell-visible, journaled text.\n   * Forward message only for error classes the host authored with model-facing\n   * text; never forward messages of transport, SDK, OS, or unknown errors,\n   * headers, URLs, or serialized causes.\n   * Undefined or a thrown renderer uses the opaque default. Permission errors\n   * and existing HarnessErrors bypass this renderer and stay in the error channel.\n   * Inspect raw causes in the host handler, redacting before any persistence.\n   */\n  readonly publicError?: ((error: E) => string | undefined) | undefined\n  /**\n   * Whether a handler failure is the flow's own timeout (a command past its\n   * limit, or a wait that gave up), and the limit in milliseconds it ran past\n   * when the failure says. Undefined for any other failure. The cell reads a\n   * timeout as a `timeout` call failure, the code of the call boundary's own\n   * limit, and a host that guards timeouts parks the run on it with this\n   * limit. Absent, every failure is `flow_failed`.\n   */\n  readonly timedOut?: ((error: E) => { readonly limitMillis?: number | undefined } | undefined) | undefined\n}\n\n/**\n * Binds one flow declaration to its runtime implementation.\n *\n * @category constructors\n * @since 0.1.0\n * @slop\n */\nexport const make = <\n  I extends SchemaTypes.Top & SchemaTypes.ConstraintDecoder<unknown, never>,\n  O extends SchemaTypes.Top & SchemaTypes.ConstraintEncoder<unknown, never>,\n  E,\n  R = never\n>(options: Options<I, O, E, R>): Binding<R> => {\n  const descriptor = descriptorOf({ ...options.flow, capabilities: [...new Set(options.flow.capabilities)].sort() }, {\n    ...options,\n    bodyDigest: options.bodyDigest ?? Digest.digest(Function.prototype.toString.call(options.handler)),\n    ...(options.inputDocument === undefined ? { inputDocument: document(options.flow.input) } : {}),\n    ...(options.outputDocument === undefined ? { outputDocument: document(options.flow.output) } : {})\n  })\n  const decodeInput = Schema.decodeUnknownResult(options.flow.input)\n  // Retry JSON nulls as omissions only where the encoded struct declares an\n  // optional field that rejects null. Other nullable fields must survive even\n  // when a sibling caused the original decode to fail. The full input schema\n  // still validates the retry, including refinements and transformations.\n  const nullKeys = omittableNullKeys(options.flow.input)\n  const decodeCall = (input: unknown): ReturnType<typeof decodeInput> => {\n    const first = decodeInput(input)\n    if (first._tag !== \"Failure\") return first\n    // A cell that omits the input (`ctx.call(\"tab.list\")`) sends JSON null.\n    // Retry it as `{}`, so an all-optional object schema accepts the call.\n    const retried = decodeInput(input === null ? {} : withoutRejectedNulls(input, nullKeys))\n    // When the retry fails too, the first attempt's failure is the one worth\n    // reporting: it names the key the caller actually wrote.\n    return retried._tag === \"Failure\" ? first : retried\n  }\n  const encodeOutput = Schema.encodeUnknownResult(options.flow.output)\n  const asJson = Schema.decodeUnknownResult(Schema.Json)\n  return {\n    descriptor,\n    run: (call) =>\n      Effect.gen(function*() {\n        const decoded = decodeCall(call.input)\n        if (decoded._tag === \"Failure\") {\n          return refusal(\n            \"invalid_input\",\n            `Flow ${descriptor.name} rejected its input: ${\n              describeFailure(decoded.failure)\n            }. Re-read ctx.flows and reissue the call.`\n          )\n        }\n        const produced = yield* Effect.result(options.handler(decoded.success, call))\n        if (produced._tag === \"Failure\") {\n          const escalate = escalated(produced.failure)\n          if (escalate !== undefined) return yield* Effect.fail(escalate)\n          const message = publicMessage(produced.failure, options.publicError)\n          const rendered = message === undefined\n            ? `Flow ${descriptor.name} failed.`\n            : `Flow ${descriptor.name} failed: ${message}`\n          const timeout = options.timedOut?.(produced.failure)\n          return timeout === undefined\n            ? refusal(\"flow_failed\", rendered)\n            : timeout.limitMillis === undefined\n            ? refusal(\"timeout\", rendered)\n            : timedOut(rendered, timeout.limitMillis)\n        }\n        const encoded = encodeOutput(produced.success)\n        if (encoded._tag === \"Failure\") {\n          return refusal(\"flow_failed\", `Flow ${descriptor.name} produced output its own schema rejects.`)\n        }\n        const json = asJson(encoded.success)\n        if (json._tag === \"Failure\") {\n          return refusal(\"flow_failed\", `Flow ${descriptor.name} produced output that is not serializable.`)\n        }\n        return new CallResult({ outcome: \"success\", value: json.success })\n      })\n  }\n}\n\n/**\n * Supplies a binding's remaining requirements from a context the host built.\n *\n * @category combinators\n * @since 0.1.0\n * @slop\n */\nexport const provide = <R, R2>(\n  self: Binding<R>,\n  services: Context.Context<R2>\n): Binding<Exclude<R, R2>> => ({\n  descriptor: self.descriptor,\n  run: (call) => Effect.provide(self.run(call), services)\n})\n\n/**\n * A named producer of executable bindings.\n *\n * Producing bindings is an effect so a source may connect a server, read a\n * manifest, or resolve a credential the first time a host composes it \u2014 the\n * lazy lifecycle an incoming MCP wrapper needs, expressed once here instead of\n * as a special case in the controller.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface Source {\n  readonly name: string\n  readonly bindings: () => Effect.Effect<ReadonlyArray<Binding>, HarnessError>\n}\n\n/**\n * Constructs a source over a fixed binding list.\n *\n * @category constructors\n * @since 0.1.0\n * @slop\n */\nexport const source = (name: string, bindings: ReadonlyArray<Binding>): Source => ({\n  name,\n  bindings: () => Effect.succeed(bindings)\n})\n\n/**\n * The deterministic composition of every executable binding a host resolved.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface Catalog {\n  /** Bindings in composition order. */\n  readonly entries: ReadonlyArray<Binding>\n  /** The same bindings, keyed by flow name. */\n  readonly bindings: ReadonlyMap<string, Binding>\n  /** The descriptors those bindings project, in composition order. */\n  readonly descriptors: ReadonlyArray<Descriptor.FlowDescriptor>\n}\n\n/** The empty catalog, which resolves nothing and discloses nothing. */\nconst emptyCatalog: Catalog = { entries: [], bindings: new Map(), descriptors: [] }\n\n/**\n * The empty catalog.\n *\n * @category constructors\n * @since 0.1.0\n * @slop\n */\nexport const empty = (): Catalog => emptyCatalog\n\nconst duplicate = (name: string): HarnessError =>\n  new HarnessError({\n    code: \"assembly_failed\",\n    message:\n      `Two executable bindings are named \"${name}\". A flow name resolves to exactly one implementation; rename one or drop it before composing the host.`\n  })\n\nconst unnamed = (): HarnessError =>\n  new HarnessError({\n    code: \"assembly_failed\",\n    message: \"An executable binding has no flow name. Give the declaration a name, or pass one to FlowBinding.make.\"\n  })\n\n/**\n * Composes bindings into a catalog, refusing duplicate names.\n *\n * @category constructors\n * @since 0.1.0\n * @slop\n */\nexport const catalogResult = (\n  bindings: ReadonlyArray<Binding>\n): Result.Result<Catalog, HarnessError> => {\n  const composed = new Map<string, Binding>()\n  const descriptors: Array<Descriptor.FlowDescriptor> = []\n  for (const binding of bindings) {\n    const name = binding.descriptor.name\n    if (name.length === 0) return Result.fail(unnamed())\n    if (composed.has(name)) return Result.fail(duplicate(name))\n    composed.set(name, binding)\n    descriptors.push(binding.descriptor)\n  }\n  return Result.succeed({\n    entries: Object.freeze([...bindings]),\n    bindings: composed,\n    descriptors: Object.freeze(descriptors)\n  })\n}\n\n/**\n * Resolves ordered sources into one catalog.\n *\n * @category constructors\n * @since 0.1.0\n * @slop\n */\nexport const catalog = (\n  sources: ReadonlyArray<Source>\n): Effect.Effect<Catalog, HarnessError> =>\n  Effect.gen(function*() {\n    const collected: Array<Binding> = []\n    for (const entry of sources) {\n      collected.push(...(yield* entry.bindings()))\n    }\n    return yield* Effect.fromResult(catalogResult(collected))\n  })\n\n/**\n * Discloses a catalog's descriptors through an existing registry.\n *\n * File-discovered entries win: a binding whose name a source already discovered\n * is not disclosed, which is what keeps `flow.ts > flow.mdx > SKILL.md`\n * precedence exactly where discovery put it. The shadowed binding is reported\n * as an ordinary `duplicate_name` warning rather than silently dispatched, and\n * the resolver refuses the shadowed name with a resolved failure envelope.\n *\n * @category constructors\n * @since 0.1.0\n * @slop\n */\nexport const registry = (base: Registry.Registry, self: Catalog): Registry.Registry => {\n  const added = (entries: ReadonlyArray<Descriptor.FlowDescriptor>): ReadonlyArray<Descriptor.FlowDescriptor> => {\n    const discovered = new Set(entries.map((entry) => entry.name))\n    return self.descriptors.filter((entry) => !discovered.has(entry.name))\n  }\n  const list = () => Effect.map(base.list(), (entries) => [...entries, ...added(entries)])\n  // Shadowing is decided against everything discovery found, never against the\n  // narrower visible set. A discovered entry that is not model-invocable still\n  // owns its name \u2014 resolving it is what `getOption` does \u2014 so deciding\n  // visibility against `base.visible()` would disclose a binding the boundary\n  // then refuses on every call, and would make `visible()` report a flow\n  // `list()` does not contain.\n  const visible = () =>\n    Effect.gen(function*() {\n      const shown = yield* base.visible()\n      const discovered = yield* base.list()\n      return [...shown, ...added(discovered).filter((entry) => entry.modelInvocable)]\n    })\n  const getOption = (name: string) =>\n    Effect.flatMap(base.getOption(name), (found) =>\n      Option.isSome(found)\n        ? Effect.succeed(found)\n        : Effect.map(base.list(), (entries) =>\n          entries.some((entry) => entry.name === name)\n            ? Option.none()\n            : Option.fromUndefinedOr(self.bindings.get(name)?.descriptor)))\n  return Registry.makeNoop({\n    list,\n    visible,\n    getOption,\n    get: (name) =>\n      Effect.flatMap(getOption(name), (found) => Option.isSome(found) ? Effect.succeed(found.value) : base.get(name)),\n    loadBody: base.loadBody,\n    runPrompt: base.runPrompt,\n    refresh: base.refresh,\n    warnings: () =>\n      Effect.gen(function*() {\n        const declared = yield* base.warnings()\n        const entries = yield* base.list()\n        const discovered = new Set(entries.map((entry) => entry.name))\n        const shadowed = self.descriptors.filter((entry) => discovered.has(entry.name)).map((entry) =>\n          new Descriptor.DiscoveryWarning({\n            code: \"duplicate_name\",\n            path: entry.path,\n            name: entry.name,\n            message:\n              `Executable binding \"${entry.name}\" is shadowed by a discovered flow; the discovered entry keeps the name.`\n          })\n        )\n        return [...declared, ...shadowed]\n      })\n  })\n}\n"],
+  "mappings": "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",
+  "names": ["callLedgerWidth"]
+}