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

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

@@ -0,0 +1 @@
+{"version":3,"file":"CellCalls.d.ts","sourceRoot":"","sources":["../../src/CellCalls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAGH,OAAO,KAAK,KAAK,QAAQ,MAAM,2BAA2B,CAAA;AAC1D,OAAO,EAAE,MAAM,EAAkB,MAAM,QAAQ,CAAA;AAC/C,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,KAAK,KAAK,WAAW,MAAM,kBAAkB,CAAA;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAGhD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,cAAc,GAAG,CAC3B,IAAI,EAAE,IAAI,CAAC,IAAI,KACZ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;AAEjD;;;;;;GAMG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,YAAY,GAAG,CACzB,MAAM,EAAE,MAAM,KACX,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;AAEjD;;;;;;GAMG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAA;IACpC;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC,OAAO,GAAG,SAAS,CAAA;IAClD,wEAAwE;IACxE,QAAQ,CAAC,eAAe,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,SAAS,CAAA;IAC1E,gGAAgG;IAChG,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,GAAG,SAAS,CAAA;CAC3C;AAED;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;CAChF;AAED;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,GAAI,SAAS,OAAO,KAAG,QAuEtC,CAAA"}

package/dist/cjs/CellCalls.js

@@ -0,0 +1,98 @@
+"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 CellCalls_exports = {};
+__export(CellCalls_exports, {
+  make: () => make
+});
+module.exports = __toCommonJS(CellCalls_exports);
+var MarkdownFlow = __toESM(require("@smthrs/registry/MarkdownFlow"), 1);
+var import_effect = require("effect");
+var Cell = __toESM(require("./Cell.js"), 1);
+var import_HarnessError = require("./HarnessError.js");
+var import_refusal = require("./internal/refusal.js");
+const make = (options) => ({
+  run: (call) => import_effect.Effect.gen(function* () {
+    const found = yield* options.registry.getOption(call.flowName);
+    if (import_effect.Option.isNone(found)) {
+      return (0, import_refusal.refusal)(
+        "unknown_flow",
+        `Flow ${call.flowName} is not in the registry. Only the flows in ctx.flows are callable.`
+      );
+    }
+    const descriptor = found.value;
+    if (!descriptor.modelInvocable) {
+      return (0, import_refusal.refusal)("capability_refused", `Flow ${call.flowName} is not model-invocable.`);
+    }
+    if (Cell.declarationDigest(descriptor) !== call.identity.declaration) {
+      return (0, import_refusal.refusal)(
+        "declaration_changed",
+        `The registry entry for ${call.flowName} changed after this cell was written. Read ctx.flows again and reissue the call.`
+      );
+    }
+    const binding = options.catalog?.bindings.get(call.flowName);
+    if (binding !== void 0) {
+      if (Cell.declarationDigest(binding.descriptor) !== Cell.declarationDigest(descriptor)) {
+        return (0, import_refusal.refusal)(
+          "declaration_changed",
+          `Flow ${call.flowName} is disclosed by a declaration that does not match the bound implementation. The host must not bind two different declarations to one name.`
+        );
+      }
+      return yield* binding.run(call);
+    }
+    if (descriptor.body._tag === "Markdown") {
+      const prompt = options.prompt;
+      if (prompt === void 0) {
+        return (0, import_refusal.refusal)("unimplemented", `Flow ${call.flowName} is a markdown flow and this host runs none.`);
+      }
+      const decoded = import_effect.Schema.decodeUnknownResult(MarkdownFlow.Input)(call.input);
+      if (decoded._tag === "Failure") {
+        return (0, import_refusal.refusal)("invalid_input", `Flow ${call.flowName} takes { args: string }.`);
+      }
+      const text = yield* options.registry.runPrompt(call.flowName, decoded.success).pipe(
+        import_effect.Effect.mapError(
+          (cause) => new import_HarnessError.HarnessError({
+            code: "engine_failed",
+            message: `The body of markdown flow ${call.flowName} could not be loaded`,
+            cause
+          })
+        )
+      );
+      return yield* prompt({ call, text });
+    }
+    const implementation = options.implementations?.get(call.flowName);
+    if (implementation === void 0) {
+      return (0, import_refusal.refusal)(
+        "unimplemented",
+        `Flow ${call.flowName} is discovered but this host has no implementation bound for it.`
+      );
+    }
+    return yield* implementation(call);
+  })
+});
+//# sourceMappingURL=CellCalls.js.map

package/dist/cjs/CellCalls.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/CellCalls.ts"],
+  "sourcesContent": ["/**\n * Registry-backed resolution for the flow calls a cell makes.\n *\n * A cell's only authority is `ctx.call(flow, input)`, so every effect an agent\n * can reach is a registered flow. This module is where a call name becomes a\n * flow: it resolves the name against `@smthrs/registry` \u2014 the same registry\n * that discovered `flow.ts`, `flow.mdx`, and `SKILL.md` under the documented\n * precedence \u2014 and dispatches to the body the descriptor declares.\n *\n * It is deliberately not a second registry. Discovery, precedence, first-found\n * collision handling, and progressive disclosure all stay in\n * `@smthrs/registry`; this module only decides which body runs and turns\n * every resolution problem into a {@link Cell.CallResult} the cell can inspect.\n *\n * The split between a failed result and a failed effect is the contract\n * `EngineLike.call` declares. A refusal the agent could plausibly correct \u2014 an\n * unknown flow, a badly shaped input, a flow this host does not implement \u2014 is\n * a `failure` result, so the cell observes a resolved `{ ok: false, error }`\n * envelope and may recover by branching on `.ok === false` and `.error.code`.\n * Ordinary call failures do not throw. Anything the cell must never swallow,\n * such as a permission park or an abort, stays in the error channel of the\n * implementation that raised it.\n *\n * The resolver's shape is exactly `FlowEngineLike.CallRunner[\"run\"]`, so a\n * durable host wires it in without this browser-safe package depending on the\n * engine binding.\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 MarkdownFlow from \"@smthrs/registry/MarkdownFlow\"\nimport type * as Registry from \"@smthrs/registry/Registry\"\nimport { Effect, Option, Schema } from \"effect\"\nimport * as Cell from \"./Cell.ts\"\nimport type * as FlowBinding from \"./FlowBinding.ts\"\nimport { HarnessError } from \"./HarnessError.ts\"\nimport { refusal } from \"./internal/refusal.ts\"\n\n/**\n * One module-backed flow, implemented by the host that discovered it.\n *\n * Discovery reads a module's metadata without evaluating it, so a descriptor\n * never carries a callable body. The host binds the implementation it loaded\n * for the flow, which keeps module evaluation out of both discovery and this\n * package.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type Implementation = (\n  call: Cell.Call\n) => Effect.Effect<Cell.CallResult, HarnessError>\n\n/**\n * One discovered markdown flow, rendered against the call's arguments.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface Prompt {\n  readonly call: Cell.Call\n  readonly text: string\n}\n\n/**\n * Runs a rendered markdown flow.\n *\n * A markdown flow is a prompt, so running one is a nested agent run rather than\n * a function call. The host supplies that runner; this module only resolves and\n * renders. A runner whose child declares the `auto` model routes that child\n * through `SeatRouter.durable` from `@smthrs/agent`, keyed by the child run.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type PromptRunner = (\n  prompt: Prompt\n) => Effect.Effect<Cell.CallResult, HarnessError>\n\n/**\n * The collaborators registry-backed resolution needs.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface Options {\n  readonly registry: Registry.Registry\n  /**\n   * The composed executable bindings this host resolved.\n   *\n   * Standard capabilities, plugin-contributed flows, incoming MCP tools, and\n   * durable children all arrive here, and all of them resolve through the one\n   * snapshot the registry disclosed.\n   */\n  readonly catalog?: FlowBinding.Catalog | undefined\n  /** Host implementations for module-backed flows, keyed by flow name. */\n  readonly implementations?: ReadonlyMap<string, Implementation> | undefined\n  /** Runs a rendered markdown flow. A host with none answers with a resolved failure envelope. */\n  readonly prompt?: PromptRunner | undefined\n}\n\n/**\n * Resolves one cell call to the registered flow that answers it.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface Resolver {\n  readonly run: (call: Cell.Call) => Effect.Effect<Cell.CallResult, HarnessError>\n}\n\n/**\n * Constructs registry-backed call resolution.\n *\n * @category constructors\n * @since 0.1.0\n * @slop\n */\nexport const make = (options: Options): Resolver => ({\n  run: (call) =>\n    Effect.gen(function*() {\n      const found = yield* options.registry.getOption(call.flowName)\n      if (Option.isNone(found)) {\n        return refusal(\n          \"unknown_flow\",\n          `Flow ${call.flowName} is not in the registry. Only the flows in ctx.flows are callable.`\n        )\n      }\n      const descriptor = found.value\n      if (!descriptor.modelInvocable) {\n        return refusal(\"capability_refused\", `Flow ${call.flowName} is not model-invocable.`)\n      }\n      // The registry is refreshable, so the entry could have moved between the\n      // frame that showed the model this catalog and the boundary that runs the\n      // call. Re-deriving the digest here is what keeps a call bound to the\n      // declaration the agent actually chose.\n      if (Cell.declarationDigest(descriptor) !== call.identity.declaration) {\n        return refusal(\n          \"declaration_changed\",\n          `The registry entry for ${call.flowName} changed after this cell was written. Read ctx.flows again and reissue the call.`\n        )\n      }\n\n      // An executable binding answers first, because a binding *is* the\n      // implementation of the declaration it projected. The identity check is\n      // what keeps that honest: if the name resolved to some other declaration\n      // \u2014 a discovered flow shadowing the binding, or two compositions crossed\n      // \u2014 the call is refused rather than dispatched to the wrong body.\n      const binding = options.catalog?.bindings.get(call.flowName)\n      if (binding !== undefined) {\n        if (Cell.declarationDigest(binding.descriptor) !== Cell.declarationDigest(descriptor)) {\n          return refusal(\n            \"declaration_changed\",\n            `Flow ${call.flowName} is disclosed by a declaration that does not match the bound implementation. The host must not bind two different declarations to one name.`\n          )\n        }\n        return yield* binding.run(call)\n      }\n\n      if (descriptor.body._tag === \"Markdown\") {\n        const prompt = options.prompt\n        if (prompt === undefined) {\n          return refusal(\"unimplemented\", `Flow ${call.flowName} is a markdown flow and this host runs none.`)\n        }\n        const decoded = Schema.decodeUnknownResult(MarkdownFlow.Input)(call.input)\n        if (decoded._tag === \"Failure\") {\n          return refusal(\"invalid_input\", `Flow ${call.flowName} takes { args: string }.`)\n        }\n        const text = yield* options.registry.runPrompt(call.flowName, decoded.success).pipe(\n          Effect.mapError((cause) =>\n            new HarnessError({\n              code: \"engine_failed\",\n              message: `The body of markdown flow ${call.flowName} could not be loaded`,\n              cause\n            })\n          )\n        )\n        return yield* prompt({ call, text })\n      }\n\n      const implementation = options.implementations?.get(call.flowName)\n      if (implementation === undefined) {\n        return refusal(\n          \"unimplemented\",\n          `Flow ${call.flowName} is discovered but this host has no implementation bound for it.`\n        )\n      }\n      return yield* implementation(call)\n    })\n})\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAiCA,mBAA8B;AAE9B,oBAAuC;AACvC,WAAsB;AAEtB,0BAA6B;AAC7B,qBAAwB;AAuFjB,MAAM,OAAO,CAAC,aAAgC;AAAA,EACnD,KAAK,CAAC,SACJ,qBAAO,IAAI,aAAY;AACrB,UAAM,QAAQ,OAAO,QAAQ,SAAS,UAAU,KAAK,QAAQ;AAC7D,QAAI,qBAAO,OAAO,KAAK,GAAG;AACxB,iBAAO;AAAA,QACL;AAAA,QACA,QAAQ,KAAK,QAAQ;AAAA,MACvB;AAAA,IACF;AACA,UAAM,aAAa,MAAM;AACzB,QAAI,CAAC,WAAW,gBAAgB;AAC9B,iBAAO,wBAAQ,sBAAsB,QAAQ,KAAK,QAAQ,0BAA0B;AAAA,IACtF;AAKA,QAAI,KAAK,kBAAkB,UAAU,MAAM,KAAK,SAAS,aAAa;AACpE,iBAAO;AAAA,QACL;AAAA,QACA,0BAA0B,KAAK,QAAQ;AAAA,MACzC;AAAA,IACF;AAOA,UAAM,UAAU,QAAQ,SAAS,SAAS,IAAI,KAAK,QAAQ;AAC3D,QAAI,YAAY,QAAW;AACzB,UAAI,KAAK,kBAAkB,QAAQ,UAAU,MAAM,KAAK,kBAAkB,UAAU,GAAG;AACrF,mBAAO;AAAA,UACL;AAAA,UACA,QAAQ,KAAK,QAAQ;AAAA,QACvB;AAAA,MACF;AACA,aAAO,OAAO,QAAQ,IAAI,IAAI;AAAA,IAChC;AAEA,QAAI,WAAW,KAAK,SAAS,YAAY;AACvC,YAAM,SAAS,QAAQ;AACvB,UAAI,WAAW,QAAW;AACxB,mBAAO,wBAAQ,iBAAiB,QAAQ,KAAK,QAAQ,8CAA8C;AAAA,MACrG;AACA,YAAM,UAAU,qBAAO,oBAAoB,aAAa,KAAK,EAAE,KAAK,KAAK;AACzE,UAAI,QAAQ,SAAS,WAAW;AAC9B,mBAAO,wBAAQ,iBAAiB,QAAQ,KAAK,QAAQ,0BAA0B;AAAA,MACjF;AACA,YAAM,OAAO,OAAO,QAAQ,SAAS,UAAU,KAAK,UAAU,QAAQ,OAAO,EAAE;AAAA,QAC7E,qBAAO;AAAA,UAAS,CAAC,UACf,IAAI,iCAAa;AAAA,YACf,MAAM;AAAA,YACN,SAAS,6BAA6B,KAAK,QAAQ;AAAA,YACnD;AAAA,UACF,CAAC;AAAA,QACH;AAAA,MACF;AACA,aAAO,OAAO,OAAO,EAAE,MAAM,KAAK,CAAC;AAAA,IACrC;AAEA,UAAM,iBAAiB,QAAQ,iBAAiB,IAAI,KAAK,QAAQ;AACjE,QAAI,mBAAmB,QAAW;AAChC,iBAAO;AAAA,QACL;AAAA,QACA,QAAQ,KAAK,QAAQ;AAAA,MACvB;AAAA,IACF;AACA,WAAO,OAAO,eAAe,IAAI;AAAA,EACnC,CAAC;AACL;",
+  "names": []
+}

package/dist/cjs/CellHistory.d.ts

@@ -0,0 +1,102 @@
+/**
+ * The source of every cell the current turn executed.
+ *
+ * The controller runs one cell per frame and, once the realm has evaluated it,
+ * keeps only what the cell printed. A model that wants to turn the script it
+ * just ran into a saved flow needs the script itself back, so this is the one
+ * place the run keeps it: the controller appends each cell as it executes, and
+ * `flows/show-script` reads the list.
+ *
+ * The service is optional. A host that offers no way to save a flow binds
+ * nothing and the controller records nothing; {@link layerNoop} states the same
+ * answer explicitly.
+ *
+ * @since 0.1.0
+ */
+import { Context, Effect, Layer } from "effect";
+/**
+ * One cell the current turn executed.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface ExecutedCell {
+    /** Zero-based execution order within this turn. */
+    readonly ordinal: number;
+    /** The cell's JavaScript, as it ran. */
+    readonly source: string;
+}
+/**
+ * Records and reports the current turn's executed cells.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Service {
+    /** Records the source of one cell the controller is executing. */
+    readonly record: (source: string) => Effect.Effect<void>;
+    /** Every cell this turn executed, oldest first. */
+    readonly cells: () => Effect.Effect<ReadonlyArray<ExecutedCell>>;
+}
+declare const CellHistory_base: Context.ServiceClass<CellHistory, "@smthrs/harness/CellHistory", Service>;
+/**
+ * Service tag for the current turn's executed cells.
+ *
+ * @category services
+ * @since 0.1.0
+ */
+export declare class CellHistory extends CellHistory_base {
+}
+/**
+ * Constructs a history that records what the controller executes.
+ *
+ * Ordinals are the append order rather than the frame number: a frame that
+ * produced no usable cell executed nothing, and a gap in the script would tell
+ * the model a cell ran that never did. `cells` answers with a copy, so a list
+ * a caller is already reading does not grow underneath it.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: Effect.Effect<Service>;
+/**
+ * Constructs a history over a fixed cell list.
+ *
+ * For a host that recorded the turn its own way and reports it rather than
+ * replaying it into {@link make}. What it is told is dropped: the list it was
+ * built over is the whole history.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const makeCells: (cells: ReadonlyArray<ExecutedCell>) => Service;
+/**
+ * Constructs a history that records nothing, optionally overriding operations.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const makeNoop: (overrides?: Partial<Service>) => Service;
+/**
+ * Provides a history that records what the controller executes.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layer: Layer.Layer<CellHistory>;
+/**
+ * Provides a history over a fixed cell list.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerCells: (cells: ReadonlyArray<ExecutedCell>) => Layer.Layer<CellHistory>;
+/**
+ * Provides a history that records nothing.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerNoop: (overrides?: Partial<Service>) => Layer.Layer<CellHistory>;
+export {};
+//# sourceMappingURL=CellHistory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CellHistory.d.ts","sourceRoot":"","sources":["../../src/CellHistory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAE/C;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,mDAAmD;IACnD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,wCAAwC;IACxC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,kEAAkE;IAClE,QAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACxD,mDAAmD;IACnD,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,CAAA;CACjE;;AAED;;;;;GAKG;AACH,qBAAa,WAAY,SAAQ,gBAAsE;CAAG;AAE1G;;;;;;;;;;GAUG;AACH,eAAO,MAAM,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAStC,CAAA;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,aAAa,CAAC,YAAY,CAAC,KAAG,OAI3D,CAAA;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,YAAW,OAAO,CAAC,OAAO,CAAM,KAAG,OAKxD,CAAA;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,WAAW,CAAmC,CAAA;AAE9E;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,aAAa,CAAC,YAAY,CAAC,KAAG,KAAK,CAAC,KAAK,CAAC,WAAW,CACzC,CAAA;AAE9C;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GAAI,YAAW,OAAO,CAAC,OAAO,CAAM,KAAG,KAAK,CAAC,KAAK,CAAC,WAAW,CACnC,CAAA"}

package/dist/cjs/CellHistory.js

@@ -0,0 +1,54 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var CellHistory_exports = {};
+__export(CellHistory_exports, {
+  CellHistory: () => CellHistory,
+  layer: () => layer,
+  layerCells: () => layerCells,
+  layerNoop: () => layerNoop,
+  make: () => make,
+  makeCells: () => makeCells,
+  makeNoop: () => makeNoop
+});
+module.exports = __toCommonJS(CellHistory_exports);
+var import_effect = require("effect");
+class CellHistory extends import_effect.Context.Service()("@smthrs/harness/CellHistory") {
+}
+const make = import_effect.Effect.sync(() => {
+  const recorded = [];
+  return CellHistory.of({
+    record: (source) => import_effect.Effect.sync(() => {
+      recorded.push({ ordinal: recorded.length, source });
+    }),
+    cells: () => import_effect.Effect.sync(() => [...recorded])
+  });
+});
+const makeCells = (cells) => CellHistory.of({
+  record: () => import_effect.Effect.void,
+  cells: () => import_effect.Effect.succeed(cells)
+});
+const makeNoop = (overrides = {}) => CellHistory.of({
+  record: () => import_effect.Effect.void,
+  cells: () => import_effect.Effect.succeed([]),
+  ...overrides
+});
+const layer = import_effect.Layer.effect(CellHistory)(make);
+const layerCells = (cells) => import_effect.Layer.succeed(CellHistory)(makeCells(cells));
+const layerNoop = (overrides = {}) => import_effect.Layer.succeed(CellHistory)(makeNoop(overrides));
+//# sourceMappingURL=CellHistory.js.map

package/dist/cjs/CellHistory.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/CellHistory.ts"],
+  "sourcesContent": ["/**\n * The source of every cell the current turn executed.\n *\n * The controller runs one cell per frame and, once the realm has evaluated it,\n * keeps only what the cell printed. A model that wants to turn the script it\n * just ran into a saved flow needs the script itself back, so this is the one\n * place the run keeps it: the controller appends each cell as it executes, and\n * `flows/show-script` reads the list.\n *\n * The service is optional. A host that offers no way to save a flow binds\n * nothing and the controller records nothing; {@link layerNoop} states the same\n * answer explicitly.\n *\n * @since 0.1.0\n */\n\nimport { Context, Effect, Layer } from \"effect\"\n\n/**\n * One cell the current turn executed.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface ExecutedCell {\n  /** Zero-based execution order within this turn. */\n  readonly ordinal: number\n  /** The cell's JavaScript, as it ran. */\n  readonly source: string\n}\n\n/**\n * Records and reports the current turn's executed cells.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Service {\n  /** Records the source of one cell the controller is executing. */\n  readonly record: (source: string) => Effect.Effect<void>\n  /** Every cell this turn executed, oldest first. */\n  readonly cells: () => Effect.Effect<ReadonlyArray<ExecutedCell>>\n}\n\n/**\n * Service tag for the current turn's executed cells.\n *\n * @category services\n * @since 0.1.0\n */\nexport class CellHistory extends Context.Service<CellHistory, Service>()(\"@smthrs/harness/CellHistory\") {}\n\n/**\n * Constructs a history that records what the controller executes.\n *\n * Ordinals are the append order rather than the frame number: a frame that\n * produced no usable cell executed nothing, and a gap in the script would tell\n * the model a cell ran that never did. `cells` answers with a copy, so a list\n * a caller is already reading does not grow underneath it.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make: Effect.Effect<Service> = Effect.sync(() => {\n  const recorded: Array<ExecutedCell> = []\n  return CellHistory.of({\n    record: (source) =>\n      Effect.sync(() => {\n        recorded.push({ ordinal: recorded.length, source })\n      }),\n    cells: () => Effect.sync(() => [...recorded])\n  })\n})\n\n/**\n * Constructs a history over a fixed cell list.\n *\n * For a host that recorded the turn its own way and reports it rather than\n * replaying it into {@link make}. What it is told is dropped: the list it was\n * built over is the whole history.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const makeCells = (cells: ReadonlyArray<ExecutedCell>): Service =>\n  CellHistory.of({\n    record: () => Effect.void,\n    cells: () => Effect.succeed(cells)\n  })\n\n/**\n * Constructs a history that records nothing, optionally overriding operations.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const makeNoop = (overrides: Partial<Service> = {}): Service =>\n  CellHistory.of({\n    record: () => Effect.void,\n    cells: () => Effect.succeed([]),\n    ...overrides\n  })\n\n/**\n * Provides a history that records what the controller executes.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layer: Layer.Layer<CellHistory> = Layer.effect(CellHistory)(make)\n\n/**\n * Provides a history over a fixed cell list.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerCells = (cells: ReadonlyArray<ExecutedCell>): Layer.Layer<CellHistory> =>\n  Layer.succeed(CellHistory)(makeCells(cells))\n\n/**\n * Provides a history that records nothing.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerNoop = (overrides: Partial<Service> = {}): Layer.Layer<CellHistory> =>\n  Layer.succeed(CellHistory)(makeNoop(overrides))\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,oBAAuC;AAkChC,MAAM,oBAAoB,sBAAQ,QAA8B,EAAE,6BAA6B,EAAE;AAAC;AAalG,MAAM,OAA+B,qBAAO,KAAK,MAAM;AAC5D,QAAM,WAAgC,CAAC;AACvC,SAAO,YAAY,GAAG;AAAA,IACpB,QAAQ,CAAC,WACP,qBAAO,KAAK,MAAM;AAChB,eAAS,KAAK,EAAE,SAAS,SAAS,QAAQ,OAAO,CAAC;AAAA,IACpD,CAAC;AAAA,IACH,OAAO,MAAM,qBAAO,KAAK,MAAM,CAAC,GAAG,QAAQ,CAAC;AAAA,EAC9C,CAAC;AACH,CAAC;AAYM,MAAM,YAAY,CAAC,UACxB,YAAY,GAAG;AAAA,EACb,QAAQ,MAAM,qBAAO;AAAA,EACrB,OAAO,MAAM,qBAAO,QAAQ,KAAK;AACnC,CAAC;AAQI,MAAM,WAAW,CAAC,YAA8B,CAAC,MACtD,YAAY,GAAG;AAAA,EACb,QAAQ,MAAM,qBAAO;AAAA,EACrB,OAAO,MAAM,qBAAO,QAAQ,CAAC,CAAC;AAAA,EAC9B,GAAG;AACL,CAAC;AAQI,MAAM,QAAkC,oBAAM,OAAO,WAAW,EAAE,IAAI;AAQtE,MAAM,aAAa,CAAC,UACzB,oBAAM,QAAQ,WAAW,EAAE,UAAU,KAAK,CAAC;AAQtC,MAAM,YAAY,CAAC,YAA8B,CAAC,MACvD,oBAAM,QAAQ,WAAW,EAAE,SAAS,SAAS,CAAC;",
+  "names": []
+}