@smthrs/gateway 0.35.0 → 1.0.0-rc.3

package/dist/cjs/internal/nodeEvents.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Shared engine node-record identity rules for the duration projection.
+ *
+ * A host copies every engine journal entry of a run into the control journal
+ * as a `control.engine.event` envelope, so the node records both executors
+ * write arrive here verbatim. The envelope's own fields are guarded the way
+ * `callEvents.ts` guards them, and the record inside it is decoded with the
+ * payload schemas `@smthrs/journal` publishes rather than with a second,
+ * hand-written copy of the same contract.
+ *
+ * @since 1.0.0
+ */
+import { EngineEvent } from "@smthrs/journal";
+/** A sparse historical observation is readable without inventing missing fields.
+ * @category models
+ * @since 1.0.0
+ */
+export interface NodeObservation {
+    readonly kind?: string | undefined;
+    readonly payload?: unknown;
+}
+/**
+ * One node record, with the envelope coordinates that scope and stamp it.
+ *
+ * `executionId` is the native run the record belongs to, which is what keeps
+ * two executions of one node id apart, and `emittedAtMs` is the native
+ * timestamp the engine wrote, which is what a duration is measured between.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface NodeRecord<Payload> {
+    readonly executionId: string;
+    readonly emittedAtMs: number;
+    readonly payload: Payload;
+}
+/** A node the executor admitted, as the engine recorded it.
+ * @category projections
+ * @since 1.0.0
+ */
+export declare const nodeScheduled: (event: NodeObservation) => NodeRecord<EngineEvent.NodeScheduledPayload> | undefined;
+/** A node that reached an outcome, as the engine recorded it.
+ * @category projections
+ * @since 1.0.0
+ */
+export declare const nodeSettled: (event: NodeObservation) => NodeRecord<EngineEvent.NodeSettledPayload> | undefined;
+//# sourceMappingURL=nodeEvents.d.ts.map

package/dist/cjs/internal/nodeEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeEvents.d.ts","sourceRoot":"","sources":["../../../src/internal/nodeEvents.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAI7C;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAClC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,UAAU,CAAC,OAAO;IACjC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAC1B;AA2CD;;;GAGG;AACH,eAAO,MAAM,aAAa,GACxB,OAAO,eAAe,KACrB,UAAU,CAAC,WAAW,CAAC,oBAAoB,CAAC,GAAG,SAC4B,CAAA;AAE9E;;;GAGG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,eAAe,KACrB,UAAU,CAAC,WAAW,CAAC,kBAAkB,CAAC,GAAG,SAC0B,CAAA"}

package/dist/cjs/internal/nodeEvents.js

@@ -0,0 +1,60 @@
+"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 nodeEvents_exports = {};
+__export(nodeEvents_exports, {
+  nodeScheduled: () => nodeScheduled,
+  nodeSettled: () => nodeSettled
+});
+module.exports = __toCommonJS(nodeEvents_exports);
+var import_journal = require("@smthrs/journal");
+var Schema = __toESM(require("effect/Schema"), 1);
+const envelopeOf = (event) => {
+  if (event.kind !== "control.engine.event" || typeof event.payload !== "object" || event.payload === null) {
+    return void 0;
+  }
+  const envelope = event.payload;
+  if (envelope.version !== 1 || typeof envelope.executionId !== "string" || typeof envelope.emittedAtMs !== "number" || !Number.isFinite(envelope.emittedAtMs)) return void 0;
+  return envelope;
+};
+const nodeRecord = (event, eventType, decode) => {
+  const envelope = envelopeOf(event);
+  if (envelope === void 0 || envelope.eventType !== eventType) return void 0;
+  const payload = decode(envelope.payload);
+  if (payload._tag === "None") return void 0;
+  return {
+    executionId: envelope.executionId,
+    emittedAtMs: envelope.emittedAtMs,
+    payload: payload.value
+  };
+};
+const decodeScheduled = Schema.decodeUnknownOption(import_journal.EngineEvent.NodeScheduledPayload);
+const decodeSettled = Schema.decodeUnknownOption(import_journal.EngineEvent.NodeSettledPayload);
+const nodeScheduled = (event) => nodeRecord(event, import_journal.EngineEvent.nodeEventTypes.nodeScheduled, decodeScheduled);
+const nodeSettled = (event) => nodeRecord(event, import_journal.EngineEvent.nodeEventTypes.nodeSettled, decodeSettled);
+//# sourceMappingURL=nodeEvents.js.map

package/dist/cjs/internal/nodeEvents.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/nodeEvents.ts"],
+  "sourcesContent": ["/**\n * Shared engine node-record identity rules for the duration projection.\n *\n * A host copies every engine journal entry of a run into the control journal\n * as a `control.engine.event` envelope, so the node records both executors\n * write arrive here verbatim. The envelope's own fields are guarded the way\n * `callEvents.ts` guards them, and the record inside it is decoded with the\n * payload schemas `@smthrs/journal` publishes rather than with a second,\n * hand-written copy of the same contract.\n *\n * @since 1.0.0\n */\n\nimport { EngineEvent } from \"@smthrs/journal\"\nimport type * as Option from \"effect/Option\"\nimport * as Schema from \"effect/Schema\"\n\n/** A sparse historical observation is readable without inventing missing fields.\n * @category models\n * @since 1.0.0\n */\nexport interface NodeObservation {\n  readonly kind?: string | undefined\n  readonly payload?: unknown\n}\n\n/**\n * One node record, with the envelope coordinates that scope and stamp it.\n *\n * `executionId` is the native run the record belongs to, which is what keeps\n * two executions of one node id apart, and `emittedAtMs` is the native\n * timestamp the engine wrote, which is what a duration is measured between.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface NodeRecord<Payload> {\n  readonly executionId: string\n  readonly emittedAtMs: number\n  readonly payload: Payload\n}\n\n/**\n * The envelope of a versioned native record, or nothing.\n *\n * Only `version`, `executionId` and `emittedAtMs` are guarded, because those\n * are the fields a duration fold reads. The native `generation` and `sequence`\n * are not: the fold pairs a settlement with the last schedule of the same\n * execution and node, in the order the control journal committed them, so\n * neither one changes what it computes.\n */\nconst envelopeOf = (event: NodeObservation): Record<string, unknown> | undefined => {\n  if (event.kind !== \"control.engine.event\" || typeof event.payload !== \"object\" || event.payload === null) {\n    return undefined\n  }\n  const envelope = event.payload as Record<string, unknown>\n  if (\n    envelope.version !== 1 || typeof envelope.executionId !== \"string\" ||\n    typeof envelope.emittedAtMs !== \"number\" || !Number.isFinite(envelope.emittedAtMs)\n  ) return undefined\n  return envelope\n}\n\n/** One record of the named type, decoded by the journal's own payload schema. */\nconst nodeRecord = <A>(\n  event: NodeObservation,\n  eventType: string,\n  decode: (payload: unknown) => Option.Option<A>\n): NodeRecord<A> | undefined => {\n  const envelope = envelopeOf(event)\n  if (envelope === undefined || envelope.eventType !== eventType) return undefined\n  const payload = decode(envelope.payload)\n  if (payload._tag === \"None\") return undefined\n  return {\n    executionId: envelope.executionId as string,\n    emittedAtMs: envelope.emittedAtMs as number,\n    payload: payload.value\n  }\n}\n\nconst decodeScheduled = Schema.decodeUnknownOption(EngineEvent.NodeScheduledPayload)\nconst decodeSettled = Schema.decodeUnknownOption(EngineEvent.NodeSettledPayload)\n\n/** A node the executor admitted, as the engine recorded it.\n * @category projections\n * @since 1.0.0\n */\nexport const nodeScheduled = (\n  event: NodeObservation\n): NodeRecord<EngineEvent.NodeScheduledPayload> | undefined =>\n  nodeRecord(event, EngineEvent.nodeEventTypes.nodeScheduled, decodeScheduled)\n\n/** A node that reached an outcome, as the engine recorded it.\n * @category projections\n * @since 1.0.0\n */\nexport const nodeSettled = (\n  event: NodeObservation\n): NodeRecord<EngineEvent.NodeSettledPayload> | undefined =>\n  nodeRecord(event, EngineEvent.nodeEventTypes.nodeSettled, decodeSettled)\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAaA,qBAA4B;AAE5B,aAAwB;AAoCxB,MAAM,aAAa,CAAC,UAAgE;AAClF,MAAI,MAAM,SAAS,0BAA0B,OAAO,MAAM,YAAY,YAAY,MAAM,YAAY,MAAM;AACxG,WAAO;AAAA,EACT;AACA,QAAM,WAAW,MAAM;AACvB,MACE,SAAS,YAAY,KAAK,OAAO,SAAS,gBAAgB,YAC1D,OAAO,SAAS,gBAAgB,YAAY,CAAC,OAAO,SAAS,SAAS,WAAW,EACjF,QAAO;AACT,SAAO;AACT;AAGA,MAAM,aAAa,CACjB,OACA,WACA,WAC8B;AAC9B,QAAM,WAAW,WAAW,KAAK;AACjC,MAAI,aAAa,UAAa,SAAS,cAAc,UAAW,QAAO;AACvE,QAAM,UAAU,OAAO,SAAS,OAAO;AACvC,MAAI,QAAQ,SAAS,OAAQ,QAAO;AACpC,SAAO;AAAA,IACL,aAAa,SAAS;AAAA,IACtB,aAAa,SAAS;AAAA,IACtB,SAAS,QAAQ;AAAA,EACnB;AACF;AAEA,MAAM,kBAAkB,OAAO,oBAAoB,2BAAY,oBAAoB;AACnF,MAAM,gBAAgB,OAAO,oBAAoB,2BAAY,kBAAkB;AAMxE,MAAM,gBAAgB,CAC3B,UAEA,WAAW,OAAO,2BAAY,eAAe,eAAe,eAAe;AAMtE,MAAM,cAAc,CACzB,UAEA,WAAW,OAAO,2BAAY,eAAe,aAAa,aAAa;",
+  "names": []
+}

package/dist/cjs/node/NodeGateway.d.ts

@@ -0,0 +1,16 @@
+/** Node HTTP adapter for the shared native gateway policy and protocol.
+ * @since 1.0.0
+ */
+import * as NativeGateway from "../internal/NativeGateway.ts";
+export { bearerPrincipal, bindRefusal, defaultServerOptions, ingressOptions, isLoopbackHost, layerAuth, listenOptions, scopedPrincipal, scopedTokenPaths } from "../internal/NativeGateway.ts";
+/** Node socket and shared gateway policy options.
+ * @since 1.0.0
+ * @category models
+ */
+export type ServerOptions = NativeGateway.ServerOptions;
+/** Hosts the existing workspace gateway on Node's scoped HTTP server.
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const layer: (health: import("../GatewayServer.ts").Health, options?: NativeGateway.ServerOptions) => import("effect/Layer").Layer<import("effect/unstable/http/HttpServer").HttpServer, import("../GatewayError.ts").GatewayError | import("@smthrs/sync/SyncError").SyncError, import("@smthrs/control/Control").Control | import("@smthrs/sync/SyncRpcs").SyncAuth | import("@smthrs/sync/SyncServer").SyncServer | import("../Projections.ts").Projections>;
+//# sourceMappingURL=NodeGateway.d.ts.map

package/dist/cjs/node/NodeGateway.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeGateway.d.ts","sourceRoot":"","sources":["../../../src/node/NodeGateway.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,aAAa,MAAM,8BAA8B,CAAA;AAE7D,OAAO,EACL,eAAe,EACf,WAAW,EACX,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,SAAS,EACT,aAAa,EACb,eAAe,EACf,gBAAgB,EACjB,MAAM,8BAA8B,CAAA;AACrC;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,aAAa,CAAC,aAAa,CAAA;AAEvD;;;GAGG;AACH,eAAO,MAAM,KAAK,obAAoF,CAAA"}

package/dist/cjs/node/NodeGateway.js

@@ -0,0 +1,48 @@
+"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 NodeGateway_exports = {};
+__export(NodeGateway_exports, {
+  bearerPrincipal: () => import_NativeGateway.bearerPrincipal,
+  bindRefusal: () => import_NativeGateway.bindRefusal,
+  defaultServerOptions: () => import_NativeGateway.defaultServerOptions,
+  ingressOptions: () => import_NativeGateway.ingressOptions,
+  isLoopbackHost: () => import_NativeGateway.isLoopbackHost,
+  layer: () => layer,
+  layerAuth: () => import_NativeGateway.layerAuth,
+  listenOptions: () => import_NativeGateway.listenOptions,
+  scopedPrincipal: () => import_NativeGateway.scopedPrincipal,
+  scopedTokenPaths: () => import_NativeGateway.scopedTokenPaths
+});
+module.exports = __toCommonJS(NodeGateway_exports);
+var NodeHttpServer = __toESM(require("../../vendor/cjs/node/NodeHttpServer.js"), 1);
+var import_node_http = require("node:http");
+var NativeGateway = __toESM(require("../internal/NativeGateway.js"), 1);
+var import_NativeGateway = require("../internal/NativeGateway.js");
+const layer = NativeGateway.makeLayer((options) => NodeHttpServer.layer(import_node_http.createServer, options));
+//# sourceMappingURL=NodeGateway.js.map

package/dist/cjs/node/NodeGateway.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/node/NodeGateway.ts"],
+  "sourcesContent": ["/** Node HTTP adapter for the shared native gateway policy and protocol.\n * @since 1.0.0\n */\n\nimport * as NodeHttpServer from \"@effect/platform-node/NodeHttpServer\"\nimport { createServer } from \"node:http\"\nimport * as NativeGateway from \"../internal/NativeGateway.ts\"\n\nexport {\n  bearerPrincipal,\n  bindRefusal,\n  defaultServerOptions,\n  ingressOptions,\n  isLoopbackHost,\n  layerAuth,\n  listenOptions,\n  scopedPrincipal,\n  scopedTokenPaths\n} from \"../internal/NativeGateway.ts\"\n/** Node socket and shared gateway policy options.\n * @since 1.0.0\n * @category models\n */\nexport type ServerOptions = NativeGateway.ServerOptions\n\n/** Hosts the existing workspace gateway on Node's scoped HTTP server.\n * @since 1.0.0\n * @category layers\n */\nexport const layer = NativeGateway.makeLayer((options) => NodeHttpServer.layer(createServer, options))\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,qBAAgC;AAChC,uBAA6B;AAC7B,oBAA+B;AAE/B,2BAUO;AAWA,MAAM,QAAQ,cAAc,UAAU,CAAC,YAAY,eAAe,MAAM,+BAAc,OAAO,CAAC;",
+  "names": []
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/esm/Diagnosis.d.ts

@@ -0,0 +1,275 @@
+/**
+ * The run diagnosis: what happened to a run, computed from its own control
+ * events.
+ *
+ * The old gateway answered this question with a `whatHappened` RPC that read
+ * run rows, node-iteration rows, and attempt rows out of the engine database
+ * and optionally asked an agent to narrate them. The rc.0 gateway serves the
+ * same answer as a field of the `run-summary` projection, computed from the
+ * ordered `ControlEvent` deltas `Control.watch` already publishes. Nothing
+ * here opens a database, so a diagnosis read through a relay is the same
+ * diagnosis a local reader computes.
+ *
+ * This is the one fold both surfaces read. `@smthrs/cli` `Forensics` calls
+ * `digest` and adds what a terminal card needs on top of it: duplicate calls,
+ * per-flow counts, the parked approval payload, and the declined-launch state
+ * the wire vocabulary does not carry. The counts, the refusal aggregation, and
+ * the clipping are therefore one implementation, not two that drift.
+ *
+ * @since 1.0.0
+ */
+import { ControlSchema } from "@smthrs/control";
+import * as Fault from "@smthrs/flow/Fault";
+import { uniqueCallEvents } from "./internal/callEvents.ts";
+import * as NativeResolution from "./internal/nativeResolution.ts";
+/**
+ * Keeps one start and settlement per durable call identity, preferring a
+ * committed native fact over telemetry at the first observation's position.
+ * Unidentified legacy events remain distinct because their identity cannot
+ * be recovered from flow names and inputs. Shared with CLI call counts.
+ *
+ * @since 1.0.0
+ * @category projections
+ */
+export { uniqueCallEvents };
+/**
+ * Native fact normalization and stable call/checkpoint identities.
+ * Incremental readers retain these keys to match the full history fold.
+ *
+ * @since 1.0.0
+ * @category projections
+ */
+export { callEventKey, callScope, nativeCallEvent, nativeStepEvent } from "./internal/callEvents.ts";
+/**
+ * Finds an open call by ID, with name/FIFO fallback only for legacy starts.
+ * Shared by gateway node output and the CLI's compatible flow/ordinal IDs.
+ *
+ * @since 1.0.0
+ * @category projections
+ */
+export { openCallIndex } from "./internal/callEvents.ts";
+/**
+ * The run statuses a digest may report.
+ *
+ * `@smthrs/control` `ControlSchema.RunStatus` is the vocabulary; this is the
+ * runtime set the fold checks a journaled kind against.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type RunStatus = ControlSchema.RunStatus;
+/**
+ * One refused flow call, aggregated by its refusal message.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface Refusal {
+    readonly message: string;
+    readonly count: number;
+}
+/**
+ * Everything the diagnosis computes from one run's events.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface Digest {
+    /** The last run status seen, or undefined before launch. */
+    readonly status: RunStatus | undefined;
+    /** The journaled failure cause, when the run failed and recorded one. */
+    readonly cause: string | undefined;
+    /** The typed fault stamped beside {@link cause}; it is written and cleared with it. */
+    readonly fault?: Fault.Fault | undefined;
+    /** The model seat the last opened turn ran on. */
+    readonly seat: string | undefined;
+    readonly turns: number;
+    readonly calls: number;
+    readonly callsFailed: number;
+    readonly editsAttempted: number;
+    readonly editsSucceeded: number;
+    /** Refusal messages, descending by count. */
+    readonly refusals: ReadonlyArray<Refusal>;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    /** USD the run's priced model calls cost; zero when none was priced. */
+    readonly costUsd: number;
+    /** The final assistant output, when the run resolved. */
+    readonly finalOutput: string | undefined;
+    /** Root binding and committed native result, retained across bounded windows. */
+    readonly nativeResolution?: NativeResolution.NativeResolution | undefined;
+    /** The pending ask's question, when the run parked for approval. */
+    readonly parkedQuestion: string | undefined;
+    /** The earliest time a kind this fold handles occurred at. */
+    readonly startedAt: number | undefined;
+    /** The latest time a kind this fold handles occurred at. */
+    readonly endedAt: number | undefined;
+}
+/**
+ * Reads a payload as a record. Wire payloads are `Json`, so every field read
+ * tolerates absence and the digest of a malformed journal is a sparse digest,
+ * never a throw.
+ *
+ * @param value the payload to read
+ * @since 1.0.0
+ * @category conversions
+ */
+export declare const asRecord: (value: unknown) => Record<string, unknown>;
+/**
+ * Reads a payload field as a string, or nothing when it is not one.
+ *
+ * @param value the field to read
+ * @since 1.0.0
+ * @category conversions
+ */
+export declare const asString: (value: unknown) => string | undefined;
+/**
+ * Reads a payload field as a number, or nothing when it is not one.
+ *
+ * @param value the field to read
+ * @since 1.0.0
+ * @category conversions
+ */
+export declare const asNumber: (value: unknown) => number | undefined;
+/**
+ * Occurrence time: the payload's own stamp, else journal admission time.
+ *
+ * @param event the event to time
+ * @since 1.0.0
+ * @category conversions
+ */
+export declare const timeOf: (event: ControlSchema.ControlEvent) => number;
+/**
+ * The first line, whichever line ending produced it. Splitting on `\n` alone
+ * left the `\r` of a CRLF cause on the wire, and every reader of a one-line
+ * field, here and in `@smthrs/cli` `Forensics`, wants the same answer.
+ *
+ * @param text the text to read one line of
+ * @since 1.0.0
+ * @category conversions
+ */
+export declare const firstLine: (text: string) => string;
+/**
+ * Truncates to a display width, marking the cut.
+ *
+ * The cut is made on code points, never on UTF-16 code units. Slicing code
+ * units splits an astral character in half and puts a lone surrogate on the
+ * wire, where a Go decoder silently replaces it with U+FFFD and a strict
+ * decoder rejects the whole frame; the result of this function is always well
+ * formed. A clipped result is exactly `width` code points, so `width` 1 is the
+ * ellipsis alone and `width` 0, or any negative width, is the empty string.
+ *
+ * @param text the text to clip
+ * @param width the greatest number of code points to keep
+ * @since 1.0.0
+ * @category rendering
+ */
+export declare const clip: (text: string, width: number) => string;
+/**
+ * The kinds this fold handles, with the class each one's fields belong to.
+ *
+ * Exported so a test can hold the table above against the map rather than
+ * trusting a comment, and so a new handler that names no class fails both the
+ * compiler and that test.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const handlerReach: Readonly<Record<string, "aggregate" | "root">>;
+/**
+ * A `control.run.*` verdict stamped with a run id other than `runId`, such as
+ * a child's riding in the parent's events. It must not set the digested run's
+ * status or failure cause. An unstamped verdict is the run's own.
+ *
+ * @param event the event to classify
+ * @param runId the run being digested; omitted, no verdict is foreign
+ * @category predicates
+ * @since 1.0.0
+ */
+export declare const foreignVerdict: (event: ControlSchema.ControlEvent, runId: string | undefined) => boolean;
+/**
+ * Folds one event range, retaining compact identities for later combination.
+ * Native facts supersede telemetry at its first position across ranges too.
+ *
+ * @param events the range to fold
+ * @param runId the run being digested; a `control.run.*` verdict stamped with
+ *   another run's id is skipped. Omitted, every verdict folds.
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const digest: (events: ReadonlyArray<ControlSchema.ControlEvent>, runId?: string) => Digest;
+/**
+ * The wall-clock span the events cover, rendered for a reader.
+ *
+ * Only the span is read, so a caller carrying a wider digest of its own, as
+ * `@smthrs/cli` `Forensics` does, measures it with this rather than a copy.
+ *
+ * @param value the span to measure
+ * @since 1.0.0
+ * @category rendering
+ */
+export declare const duration: (value: Pick<Digest, "startedAt" | "endedAt">) => string;
+/**
+ * A USD amount for a reader: cents from one dollar, four places below it, so
+ * a cheap run never reads as `$0.00`.
+ *
+ * @param value dollars, finite and non-negative
+ * @since 1.0.0
+ * @category rendering
+ */
+export declare const usd: (value: number) => string;
+/**
+ * Assistant text, or a typed module's committed result under its bound root.
+ * @category projections
+ * @since 1.0.0
+ */
+export declare const resolvedOutput: (value: Pick<Digest, "finalOutput" | "nativeResolution">) => string | undefined;
+/**
+ * The one-line verdict: the status plus the reason that most explains it.
+ *
+ * Priority order mirrors what a reader needs first: a recorded failure cause,
+ * then a park's question, then the "worked but never edited" pathology a green
+ * status would otherwise hide, then the resolved output.
+ *
+ * @param value the digest to judge
+ * @since 1.0.0
+ * @category rendering
+ */
+export declare const verdict: (value: Digest) => string;
+/**
+ * Identity a diagnosis is rendered for.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface Subject {
+    readonly runId: string;
+    readonly flowId?: string | undefined;
+}
+/**
+ * Renders the diagnosis card for one run: verdict, activity evidence, tokens,
+ * cost when any call was priced, refusals, cause, and output.
+ *
+ * @param subject the run being diagnosed
+ * @param value the digest computed from its events
+ * @since 1.0.0
+ * @category rendering
+ */
+export declare const render: (subject: Subject, value: Digest) => string;
+/**
+ * A digest of no events at all: the identity {@link combine} folds onto.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const emptyDigest: () => Digest;
+/**
+ * Combines adjacent digests without counting an identified call or checkpoint
+ * twice. A later native fact replaces the earlier telemetry contribution.
+ * Identity state is private and must stay with the in-memory digest; a plain
+ * reconstructed Digest is treated as an already aggregated, unkeyed value.
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const combine: (earlier: Digest, later: Digest) => Digest;
+//# sourceMappingURL=Diagnosis.d.ts.map

package/dist/esm/Diagnosis.d.ts.map

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