@smthrs/engine-store 0.0.0-stage → 1.0.0-rc.4

package/dist/esm/internal/JournalRecords.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JournalRecords.js","sourceRoot":"","sources":["../../../src/internal/JournalRecords.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Stable engine event constructors over the open journal envelope.\n *\n * @since 0.1.0\n */\n\nimport { Journal, JournalEvent } from \"@smthrs/journal\"\nimport type { EngineEvent } from \"@smthrs/journal\"\nimport * as Effect from \"effect/Effect\"\nimport { EventTypes } from \"../EventTypes.ts\"\n\n/**\n * The addressing every engine record shares: which run wrote it, which source\n * inside that run, and which journal lineage it belongs to.\n *\n * Only `lineageId` is a semantic requirement rather than bookkeeping — a\n * record without one is a record no time-travel frame can address — which is\n * why it is required here rather than optional.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface EventOptions {\n  readonly runId: string\n  readonly sourceId: string\n  readonly sourceSeq?: number | undefined\n  /**\n   * The journal lineage this record addresses itself to — minted by the engine\n   * (`FlowEngine.Lineage`) and carried on every engine record.\n   *\n   * Time travel (`packages/smithers/flows/time-travel/docs/README.md`) makes a frame the position\n   * `(lineageId, seq)`, and time travel's replay skips any entry whose\n   * `meta.lineageId` names a different lineage. An engine record without it is\n   * a record no frame can address, which is why this is required rather than\n   * optional: the omission used to make `TimeTravel.inspect` fail `not_found`\n   * on every journal the production composition wrote.\n   */\n  readonly lineageId: string\n  /**\n   * The step-cache key whose sealed row holds this record's result, when one\n   * exists. Replay reads it to hand the projection the sealed value instead of\n   * re-deriving it.\n   */\n  readonly cacheKey?: string | undefined\n  /**\n   * What a re-emission of this producer identity means.\n   *\n   * The default, `content`, is the strict reading: the identity names one set\n   * of bytes. `identity` is for a record whose sequence is derived from the\n   * event itself, where a collision IS the same event observed twice and the\n   * bytes that differ are metadata about the observation — a node settled\n   * `built` by the walk that ran it and `clean` by the resumed walk that\n   * replayed it is one node settling once, seen twice.\n   */\n  readonly dedupe?: JournalEvent.Dedupe | undefined\n}\n\n/**\n * The additive envelope every engine record carries.\n *\n * Kept a plain open record on purpose: `meta` is the journal's forward-compatible\n * side channel, so a consumer that does not know a key ignores it.\n */\nconst meta = (options: EventOptions): Readonly<Record<string, unknown>> => ({\n  lineageId: options.lineageId,\n  ...(options.cacheKey === undefined ? {} : { cacheKey: options.cacheKey })\n})\n\nconst event = (options: EventOptions, eventType: string, payload: unknown): JournalEvent.Input =>\n  new JournalEvent.Input({\n    runId: options.runId as JournalEvent.RunId,\n    sourceId: options.sourceId as JournalEvent.SourceId,\n    ...(options.sourceSeq === undefined ? {} : { sourceSeq: options.sourceSeq as JournalEvent.SourceSeq }),\n    ...(options.dedupe === undefined ? {} : { dedupe: options.dedupe }),\n    eventType,\n    payload,\n    meta: meta(options)\n  })\n\n/**\n * The run's state advanced. Replaying these records in order is how time\n * travel derives the state AT a frame, rather than reading the run row's\n * latest value.\n *\n * @since 0.1.0\n * @category events\n */\nexport const runDecision = (options: EventOptions, payload: unknown) => event(options, EventTypes.runDecision, payload)\n/**\n * An action attempt was admitted and its body is about to run. Paired with\n * {@link attemptFinished}; an unmatched one is crash evidence.\n *\n * @since 0.1.0\n * @category events\n */\nexport const attemptStarted = (options: EventOptions, payload: unknown) =>\n  event(options, EventTypes.attemptStarted, payload)\n/**\n * An action attempt settled, successfully or not. Closes the span opened by\n * {@link attemptStarted}.\n *\n * @since 0.1.0\n * @category events\n */\nexport const attemptFinished = (options: EventOptions, payload: unknown) =>\n  event(options, EventTypes.attemptFinished, payload)\n/**\n * A durable deferred was resolved from outside the run. Journaled because the\n * resolution is the only evidence of it — a replay cannot re-derive a value\n * that arrived over the network. The record names the completion row and the\n * digests of its encoded `exit` and `metadata`; the values stay in the row,\n * because the journal is redacted and replayed to subscribers.\n *\n * @since 0.1.0\n * @category events\n */\nexport const deferredCompleted = (options: EventOptions, payload: unknown) =>\n  event(options, EventTypes.deferredCompleted, payload)\n/**\n * A run observed a deferred's result, so registration sweeps stop waking it\n * for that result. The result itself stays in its row for replay.\n *\n * @since 1.0.0\n * @category events\n */\nexport const deferredConsumed = (options: EventOptions, payload: unknown) =>\n  event(options, EventTypes.deferredConsumed, payload)\n/**\n * A durable timer stopped being pending: it fired, or its run settled first.\n * Without it a rebuilt deadline index would re-arm a clock that already\n * completed (issue #2037).\n *\n * @since 1.0.0\n * @category events\n */\nexport const clockCompleted = (options: EventOptions, payload: unknown) =>\n  event(options, EventTypes.clockCompleted, payload)\n/**\n * The {@link clockCompleted} record for one clock, under the producer identity\n * every completer of that clock shares, so a retried completion collapses.\n *\n * @since 1.0.0\n * @category events\n */\nexport const clockCompletedFor = (\n  journalSource: string,\n  lineageId: string,\n  clock: { readonly flowName: string; readonly executionId: string; readonly clockName: string },\n  completedAtMs: number\n) =>\n  clockCompleted({\n    runId: clock.executionId,\n    lineageId,\n    sourceId: `${journalSource}:clock-completed:${\n      JSON.stringify([clock.flowName, clock.executionId, clock.clockName])\n    }`,\n    sourceSeq: 0\n  }, {\n    flowName: clock.flowName,\n    executionId: clock.executionId,\n    clockName: clock.clockName,\n    completedAtMs\n  })\n/**\n * A durable timer was armed. Journaling the schedule rather than the firing is\n * what lets a resumed run re-arm the same deadline instead of restarting the\n * wait.\n *\n * @since 0.1.0\n * @category events\n */\nexport const clockScheduled = (options: EventOptions, payload: unknown) =>\n  event(options, EventTypes.clockScheduled, payload)\n/**\n * The run was interrupted — cancelled, fenced out, or torn down — as opposed\n * to failing. Recorded so a later reader can tell a cancelled run from a\n * broken one.\n *\n * @since 0.1.0\n * @category events\n */\nexport const interrupted = (options: EventOptions, payload: unknown) =>\n  event(options, \"flows.engine.interrupted\", payload)\n/**\n * The jj pointer and plan digest in force at this point in the journal. These\n * are the two tier-2 facts replay cannot derive, which is why the engine emits\n * them and time travel's snapshot projector folds them into frame anchors.\n *\n * @since 0.1.0\n * @category events\n */\nexport const snapshotIdentified = (options: EventOptions, payload: unknown) =>\n  event(options, EventTypes.snapshotIdentified, payload)\n/**\n * A hard-mode step wrote outside its declared write set, so its result was\n * refused. The record is the forensic trail for a declaration that does not\n * match what the step actually does.\n *\n * @since 0.1.0\n * @category events\n */\nexport const hardViolation = (options: EventOptions, payload: unknown) =>\n  event(options, \"flows.engine.hard-violation\", payload)\n/**\n * An expected-mode step wrote paths its declaration did not predict. Unlike\n * {@link hardViolation} the result still stands — the declaration was a\n * prediction, and this is the record of it being wrong.\n *\n * @since 0.1.0\n * @category events\n */\nexport const expectedSetDeviation = (options: EventOptions, payload: unknown) =>\n  event(options, \"flows.engine.expected-set-deviation\", payload)\n/**\n * An isolated execution produced a diff bundle: its content address, the paths\n * it changed, and the deviations the declaration did not predict. One of the\n * two record types copy-back writes.\n *\n * It is written once the attempt's copy-back has settled, not before it — the\n * rebase loop owns the window in between, and a bundle that lost every race\n * was never a proposal the host saw. A crash inside that window leaves the\n * attempt row unfinished, so the replay re-executes and journals the bundle it\n * actually applies. An execution the declaration invalidated journals nothing\n * here at all; its `hard-violation` record carries the identity instead.\n *\n * @since 0.1.0\n * @category events\n */\nexport const diffBundleCaptured = (options: EventOptions, payload: unknown) =>\n  event(options, \"flows.engine.diff-bundle-captured\", payload)\n/**\n * A diff bundle reached the host. Carries the rebase count, the deduplicated\n * `queued` effect keys, and the `dispatched` keys the delivery stage sent.\n * `dispatched` is present and empty when no `EffectDispatcher` is composed, so\n * the absence of delivery is a journal fact rather than an inference.\n *\n * @since 0.1.0\n * @category events\n */\nexport const copyBackSettled = (options: EventOptions, payload: unknown) =>\n  event(options, \"flows.engine.copy-back-settled\", payload)\n/**\n * A plan was recorded and a run is about to be driven under it. Carries the\n * plan id, its generation-0 digest, and its node count, so\n * `packages/smithers/flows/plan/docs/api.md` asks the audit question, \"show me the plan this ran\n * under\". This record answers it exactly rather than reconstructing it.\n *\n * @since 0.1.0\n * @category events\n */\nexport const planRecorded = (options: EventOptions, payload: EngineEvent.PlanRecordedPayload) =>\n  event(options, EventTypes.planRecorded, payload)\n/**\n * An elaboration appended a pre-keyed subgraph to the SAME plan. The plan\n * grows; it is never invalidated, so this record names the new generation, the\n * advanced digest, and the node ids added — never a replacement graph.\n *\n * @since 0.1.0\n * @category events\n */\nexport const subgraphAppended = (options: EventOptions, payload: EngineEvent.SubgraphAppendedPayload) =>\n  event(options, EventTypes.subgraphAppended, payload)\n/**\n * A plan node was admitted to the scheduler: its caps and seats allowed it,\n * and its effective priority selected it. Paired with `node-settled`, this is\n * the queue-time evidence the journal measures.\n *\n * @since 0.1.0\n * @category events\n */\nexport const nodeScheduled = (options: EventOptions, payload: EngineEvent.NodeScheduledPayload) =>\n  event(options, \"flows.engine.node-scheduled\", payload)\n/**\n * A plan node reached an evaluation outcome. Skyframe's\n * `EvaluationProgressReceiver.EvaluationState` is the prior art:\n * `SUCCESS_VERSION_CHANGED`/`SUCCESS_VERSION_UNCHANGED` map onto `built`/\n * `clean`, and where Skyframe splits failure by version we use `failed` and\n * `skipped` — a content-addressed store never serves a failure from cache, so\n * `FAIL_VERSION_UNCHANGED` has no analogue, while a dependent that never ran\n * because its cone failed does. `deferred` is the one outcome outside the\n * Skyframe quadruple: a scheduling debt recorded by probabilistic selection,\n * not an evaluation state.\n *\n * @since 0.1.0\n * @category events\n */\nexport const nodeSettled = (options: EventOptions, payload: EngineEvent.NodeSettledPayload) =>\n  event(options, \"flows.engine.node-settled\", payload)\n/**\n * A scheduled node's dispatch identity was invalidated: its measured inputs no\n * longer match the ones its key was computed from, so it is re-keyed and\n * re-dispatched. Invalidation is re-keying — there is no dirty bit and no\n * invalidating visitor to journal.\n *\n * @since 0.1.0\n * @category events\n */\nexport const nodeInvalidated = (options: EventOptions, payload: EngineEvent.NodeInvalidatedPayload) =>\n  event(options, \"flows.engine.node-invalidated\", payload)\n/**\n * The reconciliation seam returned a verdict for a deviation or an unabsorbed\n * materialization conflict.\n *\n * @since 0.1.0\n * @category events\n */\nexport const nodeReconciled = (options: EventOptions, payload: EngineEvent.NodeReconciledPayload) =>\n  event(options, \"flows.engine.node-reconciled\", payload)\n/**\n * A selection guess postponed a sink node: it did not execute, wrote no cache\n * row, and this record is the debt — node id, plan key, the suspected edge,\n * and the likelihood — that a later guess-free pass repays. `Selection.debt`\n * folds these against {@link nodeSettled} records to list what is still owed.\n *\n * @since 0.1.0\n * @category events\n */\nexport const selectionDeferred = (options: EventOptions, payload: unknown) =>\n  event(options, \"flows.engine.selection-deferred\", payload)\n/**\n * A selection guess proposed a flow no real dependency reaches. V1 records\n * and surfaces the proposal; it never auto-appends plan nodes, so this record\n * is the proposal's only artifact.\n *\n * @since 0.1.0\n * @category events\n */\nexport const selectionProposed = (options: EventOptions, payload: unknown) =>\n  event(options, \"flows.engine.selection-proposed\", payload)\n/**\n * A run forced full selection: every verdict was treated as `Admit`, the way\n * `--fresh` ignores the cache. Journaled so a report can say the guesses were\n * overridden rather than absent.\n *\n * @since 0.1.0\n * @category events\n */\nexport const selectionOverridden = (options: EventOptions, payload: unknown) =>\n  event(options, \"flows.engine.selection-overridden\", payload)\n/**\n * A selection layer returned a Defer or Propose verdict naming a non-sink.\n * The verdict is ignored — only sinks are deferrable — and this observation\n * records the layer disagreeing with the plan's shape, in the pattern of\n * Skyframe's `GraphInconsistencyReceiver`: note it, never wire the detector\n * to /dev/null.\n *\n * @since 0.1.0\n * @category events\n */\nexport const selectionInconsistent = (options: EventOptions, payload: unknown) =>\n  event(options, \"flows.engine.selection-inconsistent\", payload)\n/**\n * Where a reused result came from: which run first produced it and under which\n * key. A cache hit is otherwise invisible in the journal, and provenance is\n * what makes one auditable after the fact.\n *\n * @since 0.1.0\n * @category events\n */\nexport const cacheProvenance = (options: EventOptions, payload: unknown) =>\n  event(options, \"flows.engine.cache-provenance\", payload)\n/**\n * Two runs recorded different results under one step key — the journaled form\n * of an under-specified declaration.\n *\n * @since 0.1.0\n * @category events\n */\nexport const cacheConflict = (options: EventOptions, payload: unknown) =>\n  event(options, \"flows.engine.cache-conflict\", payload)\n/**\n * A cached output failed its digest check and the entry was evicted. Journaled\n * because a repeat is a failing disk, not a coincidence.\n *\n * @since 0.1.0\n * @category events\n */\nexport const cacheCorruption = (options: EventOptions, payload: unknown) =>\n  event(options, \"flows.engine.cache-corruption\", payload)\n\n/**\n * Reads a page of engine records without imposing an agent-shaped event union.\n *\n * @since 0.1.0\n * @category queries\n */\nexport const entries = (runId: string, after: number | undefined, limit: number) =>\n  Effect.flatMap(\n    Journal.Journal,\n    (journal) =>\n      journal.entries({\n        runId: runId as JournalEvent.RunId,\n        ...(after === undefined ? {} : { after: after as JournalEvent.Seq }),\n        limit\n      })\n  )\n"]}

package/dist/esm/internal/NodeJournal.d.ts

@@ -0,0 +1,157 @@
+/**
+ * The interpreter's node records, as journal entries.
+ *
+ * `@smthrs/flow` builds a record for the graph it drove and for every node it
+ * scheduled and settled, and says nothing about where they go. This module is
+ * the durable store's answer: one journal entry per record, addressed by the
+ * record's own `sourceId`, typed by the payload schemas `@smthrs/journal`
+ * publishes, and carrying the same event types the plan scheduler writes so a
+ * reader folds both executors with one decoder.
+ *
+ * Two facts live here rather than in the interpreter. The journal's producer
+ * identity is `(runId, sourceId, sourceSeq)`, so a resumed walk that
+ * re-derives the same `sourceId` collapses onto the row the first walk wrote:
+ * that is the exactly-once contract, and it holds because the identity is the
+ * record's, never a fresh one minted per observation. And a declaration site
+ * is made repo-relative here, because only the writer knows the root: a
+ * journal is read on machines that did not write it, and an absolute path is
+ * at best noise and at worst an operator's home directory published into a
+ * run's history.
+ *
+ * @since 0.1.0
+ */
+import type { FlowRuntime } from "@smthrs/flow";
+import { JournalEvent } from "@smthrs/journal";
+/**
+ * Where the records of one run are addressed from.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Scope {
+    readonly runId: string;
+    /** The host's journal source, which every record of this run hangs under. */
+    readonly sourceId: string;
+    readonly lineageId: string;
+    /**
+     * The directory a declaration path is made relative to, when one is known.
+     *
+     * `undefined` means no path is recorded at all. That is the honest answer
+     * for a host that cannot say where its sources live, and it is better than
+     * a path a reader would have to guess the meaning of.
+     */
+    readonly root?: string | undefined;
+    /**
+     * The revision the sources those declaration paths point into were read
+     * at, when the host can name one.
+     *
+     * It lives here for the reason `root` does: a journal is read on machines
+     * that did not write it, and only the writer knows which tree it loaded.
+     * A path alone says where a node was declared and never which bytes were
+     * at that line, so a reader without this opens no code at all rather than
+     * whatever the working tree holds when they look (D-068).
+     */
+    readonly sourceRevision?: string | undefined;
+}
+/**
+ * A declaration path as a journal may carry it: relative to the root, or
+ * nothing.
+ *
+ * The rule lives with the schema that refuses an absolute path
+ * (`@smthrs/journal`'s `EngineEvent.DeclaredAt`), so every writer of a
+ * declaration site obeys it the same way. It is named here because this is
+ * the module that applies it, and because the store's own tests are written
+ * against it.
+ *
+ * @since 0.1.0
+ * @category accessors
+ */
+export declare const relativePath: (root: string | undefined, path: string) => string | undefined;
+/**
+ * The directory declaration paths are recorded relative to.
+ *
+ * `process` is absent in a worker and in a browser, and a host that cannot
+ * name its own working directory records no declaration path at all rather
+ * than one a reader would have to guess the meaning of. `host` is the global
+ * object by default and is named here so both answers are reachable without
+ * taking the real one away from the runtime.
+ *
+ * @since 0.1.0
+ * @category accessors
+ */
+export declare const hostRoot: (explicit: string | undefined, host?: {
+    readonly process?: {
+        readonly cwd?: () => string;
+    } | undefined;
+}) => string | undefined;
+/**
+ * How many bytes of a node's settled value a journal row keeps.
+ *
+ * A node record is a small row beside the plan record's 12,000-byte page
+ * budget, and it is written once per node of every graph: a value kept whole
+ * would put an agent transcript in a permanent row and a projection would
+ * clip it without saying so. Two kibibytes is enough to read what a node
+ * produced and small enough that the settlement stays a summary.
+ *
+ * @since 0.1.0
+ * @category constants
+ */
+export declare const maximumResultBytes = 2048;
+/**
+ * How large a settled value may be before it is summarized at all.
+ *
+ * Redacting a value rebuilds every member of it and runs the textual rules
+ * over every string, on the journal write path, for every node of every
+ * graph. Past this ceiling the walk is the cost rather than the row, and the
+ * honest answer is the size alone: the encoding is measured, `preview` is
+ * empty, and `truncated` says the text was cut to nothing. Anything below it
+ * is redacted whole and then cut.
+ *
+ * @since 0.1.0
+ * @category constants
+ */
+export declare const maximumSummarizedBytes = 65536;
+/**
+ * What a node settled with, redacted and then bounded.
+ *
+ * REDACTION COMES FIRST. `Redaction.redact` is the journal's own write-path
+ * scrubber, and it is the one that reads a field NAME: `{ apiKey: "sk-..." }`
+ * is a credential because of the key, which no rule over encoded text can see
+ * once the value is a string inside a larger string. Running it over the
+ * decoded value also collapses cycles and names functions, so the encoding
+ * that follows always succeeds. Cutting the text first would be worse than
+ * useless: a credential split across the boundary is a credential the textual
+ * rules no longer recognise, and half of it would be kept.
+ *
+ * A value that will not encode even after redaction — a bigint, a value whose
+ * own `toJSON` throws — gets no summary at all rather than a fabricated one.
+ *
+ * `bytes` is the size of the encoding `preview` was cut from, which for a
+ * value past {@link maximumSummarizedBytes} is the value's own encoding: that
+ * branch keeps nothing, so there is no second number to disagree with.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const resultSummary: (value: unknown) => {
+    readonly preview: string;
+    readonly bytes: number;
+    readonly truncated: boolean;
+} | undefined;
+/**
+ * The journal entry one node record is written as.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const entry: (scope: Scope, record: FlowRuntime.NodeRecord) => JournalEvent.Input;
+/**
+ * UTF-8 upper bound for the durable entry, including allocated envelope fields.
+ *
+ * Sequence/time reserve their largest JSON encodings so page boundaries never
+ * depend on the current journal position or clock, including after a resume.
+ * @since 1.0.0
+ * @category accessors
+ */
+export declare const encodedBytes: (scope: Scope, record: FlowRuntime.NodeRecord) => number;
+//# sourceMappingURL=NodeJournal.d.ts.map

package/dist/esm/internal/NodeJournal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeJournal.d.ts","sourceRoot":"","sources":["../../../src/internal/NodeJournal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAe,YAAY,EAAa,MAAM,iBAAiB,CAAA;AAItE;;;;;GAKG;AACH,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,6EAA6E;IAC7E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAClC;;;;;;;;;OASG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC7C;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,gEAA2B,CAAA;AAapD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,QAAQ,GACnB,UAAU,MAAM,GAAG,SAAS,EAC5B,OAAM;IAAE,QAAQ,CAAC,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;KAAE,GAAG,SAAS,CAAA;CAAe,KACpF,MAAM,GAAG,SAGX,CAAA;AAsBD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,OAAQ,CAAA;AAEvC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,sBAAsB,QAAS,CAAA;AA2C5C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,KAAG;IAC7C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC5B,GAAG,SA2BH,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,OAAO,KAAK,EAAE,QAAQ,WAAW,CAAC,UAAU,KAAG,YAAY,CAAC,KA0DjF,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,KAAK,EAAE,QAAQ,WAAW,CAAC,UAAU,KAAG,MAc3E,CAAA"}

package/dist/esm/internal/NodeJournal.js

@@ -0,0 +1,298 @@
+/**
+ * The interpreter's node records, as journal entries.
+ *
+ * `@smthrs/flow` builds a record for the graph it drove and for every node it
+ * scheduled and settled, and says nothing about where they go. This module is
+ * the durable store's answer: one journal entry per record, addressed by the
+ * record's own `sourceId`, typed by the payload schemas `@smthrs/journal`
+ * publishes, and carrying the same event types the plan scheduler writes so a
+ * reader folds both executors with one decoder.
+ *
+ * Two facts live here rather than in the interpreter. The journal's producer
+ * identity is `(runId, sourceId, sourceSeq)`, so a resumed walk that
+ * re-derives the same `sourceId` collapses onto the row the first walk wrote:
+ * that is the exactly-once contract, and it holds because the identity is the
+ * record's, never a fresh one minted per observation. And a declaration site
+ * is made repo-relative here, because only the writer knows the root: a
+ * journal is read on machines that did not write it, and an absolute path is
+ * at best noise and at worst an operator's home directory published into a
+ * run's history.
+ *
+ * @since 0.1.0
+ */
+import { EngineEvent, JournalEvent, Redaction } from "@smthrs/journal";
+import * as JournalRecords from "./JournalRecords.js";
+/**
+ * A declaration path as a journal may carry it: relative to the root, or
+ * nothing.
+ *
+ * The rule lives with the schema that refuses an absolute path
+ * (`@smthrs/journal`'s `EngineEvent.DeclaredAt`), so every writer of a
+ * declaration site obeys it the same way. It is named here because this is
+ * the module that applies it, and because the store's own tests are written
+ * against it.
+ *
+ * @since 0.1.0
+ * @category accessors
+ */
+export const relativePath = EngineEvent.relativePath;
+/**
+ * A value the journal will serialize, typed as what it will be.
+ *
+ * A node's effects are JSON by construction, but an optional member spelled
+ * `undefined` is not assignable to `Json` under `exactOptionalPropertyTypes`,
+ * and serialization is exactly what drops it. This is the journal's own
+ * encoding performed one step early, so the type says what the stored value
+ * is rather than asserting it. @private
+ */
+const asJson = (value) => JSON.parse(JSON.stringify(value));
+/**
+ * The directory declaration paths are recorded relative to.
+ *
+ * `process` is absent in a worker and in a browser, and a host that cannot
+ * name its own working directory records no declaration path at all rather
+ * than one a reader would have to guess the meaning of. `host` is the global
+ * object by default and is named here so both answers are reachable without
+ * taking the real one away from the runtime.
+ *
+ * @since 0.1.0
+ * @category accessors
+ */
+export const hostRoot = (explicit, host = globalThis) => {
+    if (explicit !== undefined)
+        return explicit;
+    return typeof host.process?.cwd === "function" ? host.process.cwd() : undefined;
+};
+const summary = (scope, node) => {
+    const path = node.declaredAt === undefined ? undefined : relativePath(scope.root, node.declaredAt.path);
+    return {
+        id: node.id,
+        kind: node.kind,
+        dependsOn: node.dependsOn,
+        tier: node.tier,
+        ...(node.action === undefined ? {} : { action: node.action }),
+        ...(node.effects === undefined ? {} : { effects: asJson(node.effects) }),
+        ...(path === undefined ? {} : { declaredAt: { path, line: node.declaredAt.line } })
+    };
+};
+const graph = (scope, record) => ({
+    nodes: record.nodes.map((node) => summary(scope, node)),
+    edges: record.edges,
+    // On every page, because every page carries its own sites.
+    ...(scope.sourceRevision === undefined ? {} : { sourceRevision: scope.sourceRevision })
+});
+/**
+ * How many bytes of a node's settled value a journal row keeps.
+ *
+ * A node record is a small row beside the plan record's 12,000-byte page
+ * budget, and it is written once per node of every graph: a value kept whole
+ * would put an agent transcript in a permanent row and a projection would
+ * clip it without saying so. Two kibibytes is enough to read what a node
+ * produced and small enough that the settlement stays a summary.
+ *
+ * @since 0.1.0
+ * @category constants
+ */
+export const maximumResultBytes = 2_048;
+/**
+ * How large a settled value may be before it is summarized at all.
+ *
+ * Redacting a value rebuilds every member of it and runs the textual rules
+ * over every string, on the journal write path, for every node of every
+ * graph. Past this ceiling the walk is the cost rather than the row, and the
+ * honest answer is the size alone: the encoding is measured, `preview` is
+ * empty, and `truncated` says the text was cut to nothing. Anything below it
+ * is redacted whole and then cut.
+ *
+ * @since 0.1.0
+ * @category constants
+ */
+export const maximumSummarizedBytes = 65_536;
+/** The redactor a node summary is scrubbed with, built once. @private */
+const redactor = Redaction.make({ onTooDeep: "name" });
+/** UTF-8 bytes of a string, without allocating the encoding. @private */
+const utf8Bytes = (text) => {
+    let bytes = 0;
+    for (let index = 0; index < text.length; index++) {
+        const code = text.charCodeAt(index);
+        if (code < 0x80)
+            bytes += 1;
+        else if (code < 0x800)
+            bytes += 2;
+        else if (code >= 0xd800 && code <= 0xdbff && index + 1 < text.length) {
+            bytes += 4;
+            index++;
+        }
+        else
+            bytes += 3;
+    }
+    return bytes;
+};
+/**
+ * The longest prefix of `text` within `limit` UTF-8 bytes, never splitting a
+ * pair.
+ *
+ * One cut, taken where the walk stopped, because the walk stops for two
+ * reasons and only one of them can happen: the caller asks only for text it
+ * has already measured as over the limit, so a second exit for text that fits
+ * whole would be a line no run reaches. @private
+ */
+const clampToBytes = (text, limit) => {
+    let bytes = 0;
+    let index = 0;
+    while (index < text.length) {
+        const code = text.charCodeAt(index);
+        const pair = code >= 0xd800 && code <= 0xdbff && index + 1 < text.length;
+        const size = code < 0x80 ? 1 : code < 0x800 ? 2 : pair ? 4 : 3;
+        if (bytes + size > limit)
+            break;
+        bytes += size;
+        index += pair ? 2 : 1;
+    }
+    return text.slice(0, index);
+};
+/**
+ * What a node settled with, redacted and then bounded.
+ *
+ * REDACTION COMES FIRST. `Redaction.redact` is the journal's own write-path
+ * scrubber, and it is the one that reads a field NAME: `{ apiKey: "sk-..." }`
+ * is a credential because of the key, which no rule over encoded text can see
+ * once the value is a string inside a larger string. Running it over the
+ * decoded value also collapses cycles and names functions, so the encoding
+ * that follows always succeeds. Cutting the text first would be worse than
+ * useless: a credential split across the boundary is a credential the textual
+ * rules no longer recognise, and half of it would be kept.
+ *
+ * A value that will not encode even after redaction — a bigint, a value whose
+ * own `toJSON` throws — gets no summary at all rather than a fabricated one.
+ *
+ * `bytes` is the size of the encoding `preview` was cut from, which for a
+ * value past {@link maximumSummarizedBytes} is the value's own encoding: that
+ * branch keeps nothing, so there is no second number to disagree with.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export const resultSummary = (value) => {
+    // The size first, from the value's own encoding, because it is the cheap
+    // half: a value this row will not keep is named by its size and never
+    // walked. A value that will not encode at all — a cycle, a bigint, a
+    // throwing `toJSON` — says nothing here, and the redactor below is asked,
+    // because it collapses cycles and names what it cannot rewrite.
+    let raw;
+    try {
+        raw = JSON.stringify(value);
+    }
+    catch {
+        raw = undefined;
+    }
+    if (raw !== undefined) {
+        const rawBytes = utf8Bytes(raw);
+        if (rawBytes > maximumSummarizedBytes)
+            return { preview: "", bytes: rawBytes, truncated: true };
+    }
+    let encoded;
+    try {
+        encoded = JSON.stringify(redactor(value));
+    }
+    catch {
+        return undefined;
+    }
+    if (encoded === undefined)
+        return undefined;
+    const bytes = utf8Bytes(encoded);
+    if (bytes > maximumSummarizedBytes)
+        return { preview: "", bytes, truncated: true };
+    if (bytes <= maximumResultBytes)
+        return { preview: encoded, bytes, truncated: false };
+    return { preview: clampToBytes(encoded, maximumResultBytes), bytes, truncated: true };
+};
+/**
+ * The journal entry one node record is written as.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export const entry = (scope, record) => {
+    const options = {
+        runId: scope.runId,
+        sourceId: `${scope.sourceId}/${record.sourceId}`,
+        lineageId: scope.lineageId,
+        // Without an explicit sequence the journal ALLOCATES the next one for the
+        // source, so a resumed walk would write a second row for every node it
+        // re-derived. Pinning it to zero makes the re-emission an exact producer
+        // retry, which is the whole of the exactly-once contract.
+        sourceSeq: 0,
+        // The sequence is derived from the record's own identity, so a collision
+        // is the same node observed twice rather than two nodes wearing one
+        // address. What differs between the observations is metadata ABOUT the
+        // observation — a node the first walk BUILT settles CLEAN on the walk
+        // that replayed it — and the first row, the one that says what actually
+        // happened, stands.
+        dedupe: "identity"
+    };
+    switch (record._tag) {
+        case "PlanRecorded":
+            return JournalRecords.planRecorded(options, {
+                flow: record.flow,
+                generation: record.generation,
+                // The node COUNT of the whole graph, which is what this field has
+                // always meant; the node LIST rides beside it as `graph`.
+                nodes: record.nodeCount,
+                page: record.page,
+                pages: record.pages,
+                graph: graph(scope, record)
+            });
+        case "SubgraphAppended":
+            return JournalRecords.subgraphAppended(options, {
+                flow: record.flow,
+                generation: record.generation,
+                nodeIds: record.nodes.map((node) => node.id),
+                page: record.page,
+                pages: record.pages,
+                graph: graph(scope, record)
+            });
+        case "NodeScheduled":
+            return JournalRecords.nodeScheduled(options, {
+                nodeId: record.nodeId,
+                kind: record.kind,
+                attempt: record.attempt,
+                ...(record.action === undefined ? {} : { action: record.action })
+            });
+        case "NodeSettled": {
+            const result = record.value === undefined ? undefined : resultSummary(record.value);
+            return JournalRecords.nodeSettled(options, {
+                nodeId: record.nodeId,
+                outcome: record.outcome,
+                attempts: record.attempts,
+                stepKeyDigests: record.stepKeyDigests,
+                ...(record.action === undefined ? {} : { action: record.action }),
+                ...(result === undefined ? {} : { result })
+            });
+        }
+    }
+};
+/**
+ * UTF-8 upper bound for the durable entry, including allocated envelope fields.
+ *
+ * Sequence/time reserve their largest JSON encodings so page boundaries never
+ * depend on the current journal position or clock, including after a resume.
+ * @since 1.0.0
+ * @category accessors
+ */
+export const encodedBytes = (scope, record) => {
+    const input = entry(scope, record);
+    const sourceSeq = JournalEvent.SourceSeq.make(0);
+    return new TextEncoder().encode(JSON.stringify({
+        runId: input.runId,
+        seq: Number.MAX_SAFE_INTEGER - 1,
+        eventId: JournalEvent.makeEventId(input.runId, input.sourceId, sourceSeq),
+        sourceId: input.sourceId,
+        sourceSeq,
+        emittedAtMs: Number.MAX_VALUE,
+        eventType: input.eventType,
+        payload: redactor(input.payload),
+        meta: redactor(input.meta)
+    })).byteLength;
+};
+//# sourceMappingURL=NodeJournal.js.map

package/dist/esm/internal/NodeJournal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeJournal.js","sourceRoot":"","sources":["../../../src/internal/NodeJournal.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The interpreter's node records, as journal entries.\n *\n * `@smthrs/flow` builds a record for the graph it drove and for every node it\n * scheduled and settled, and says nothing about where they go. This module is\n * the durable store's answer: one journal entry per record, addressed by the\n * record's own `sourceId`, typed by the payload schemas `@smthrs/journal`\n * publishes, and carrying the same event types the plan scheduler writes so a\n * reader folds both executors with one decoder.\n *\n * Two facts live here rather than in the interpreter. The journal's producer\n * identity is `(runId, sourceId, sourceSeq)`, so a resumed walk that\n * re-derives the same `sourceId` collapses onto the row the first walk wrote:\n * that is the exactly-once contract, and it holds because the identity is the\n * record's, never a fresh one minted per observation. And a declaration site\n * is made repo-relative here, because only the writer knows the root: a\n * journal is read on machines that did not write it, and an absolute path is\n * at best noise and at worst an operator's home directory published into a\n * run's history.\n *\n * @since 0.1.0\n */\n\nimport type { FlowRuntime } from \"@smthrs/flow\"\nimport { EngineEvent, JournalEvent, Redaction } from \"@smthrs/journal\"\nimport type * as Schema from \"effect/Schema\"\nimport * as JournalRecords from \"./JournalRecords.ts\"\n\n/**\n * Where the records of one run are addressed from.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Scope {\n  readonly runId: string\n  /** The host's journal source, which every record of this run hangs under. */\n  readonly sourceId: string\n  readonly lineageId: string\n  /**\n   * The directory a declaration path is made relative to, when one is known.\n   *\n   * `undefined` means no path is recorded at all. That is the honest answer\n   * for a host that cannot say where its sources live, and it is better than\n   * a path a reader would have to guess the meaning of.\n   */\n  readonly root?: string | undefined\n  /**\n   * The revision the sources those declaration paths point into were read\n   * at, when the host can name one.\n   *\n   * It lives here for the reason `root` does: a journal is read on machines\n   * that did not write it, and only the writer knows which tree it loaded.\n   * A path alone says where a node was declared and never which bytes were\n   * at that line, so a reader without this opens no code at all rather than\n   * whatever the working tree holds when they look (D-068).\n   */\n  readonly sourceRevision?: string | undefined\n}\n\n/**\n * A declaration path as a journal may carry it: relative to the root, or\n * nothing.\n *\n * The rule lives with the schema that refuses an absolute path\n * (`@smthrs/journal`'s `EngineEvent.DeclaredAt`), so every writer of a\n * declaration site obeys it the same way. It is named here because this is\n * the module that applies it, and because the store's own tests are written\n * against it.\n *\n * @since 0.1.0\n * @category accessors\n */\nexport const relativePath = EngineEvent.relativePath\n\n/**\n * A value the journal will serialize, typed as what it will be.\n *\n * A node's effects are JSON by construction, but an optional member spelled\n * `undefined` is not assignable to `Json` under `exactOptionalPropertyTypes`,\n * and serialization is exactly what drops it. This is the journal's own\n * encoding performed one step early, so the type says what the stored value\n * is rather than asserting it. @private\n */\nconst asJson = (value: unknown): typeof Schema.Json.Type => JSON.parse(JSON.stringify(value))\n\n/**\n * The directory declaration paths are recorded relative to.\n *\n * `process` is absent in a worker and in a browser, and a host that cannot\n * name its own working directory records no declaration path at all rather\n * than one a reader would have to guess the meaning of. `host` is the global\n * object by default and is named here so both answers are reachable without\n * taking the real one away from the runtime.\n *\n * @since 0.1.0\n * @category accessors\n */\nexport const hostRoot = (\n  explicit: string | undefined,\n  host: { readonly process?: { readonly cwd?: () => string } | undefined } = globalThis\n): string | undefined => {\n  if (explicit !== undefined) return explicit\n  return typeof host.process?.cwd === \"function\" ? host.process.cwd() : undefined\n}\n\nconst summary = (scope: Scope, node: FlowRuntime.NodeSummary) => {\n  const path = node.declaredAt === undefined ? undefined : relativePath(scope.root, node.declaredAt.path)\n  return {\n    id: node.id,\n    kind: node.kind,\n    dependsOn: node.dependsOn,\n    tier: node.tier,\n    ...(node.action === undefined ? {} : { action: node.action }),\n    ...(node.effects === undefined ? {} : { effects: asJson(node.effects) }),\n    ...(path === undefined ? {} : { declaredAt: { path, line: node.declaredAt!.line } })\n  }\n}\n\nconst graph = (scope: Scope, record: FlowRuntime.PlanRecorded | FlowRuntime.SubgraphAppended) => ({\n  nodes: record.nodes.map((node) => summary(scope, node)),\n  edges: record.edges,\n  // On every page, because every page carries its own sites.\n  ...(scope.sourceRevision === undefined ? {} : { sourceRevision: scope.sourceRevision })\n})\n\n/**\n * How many bytes of a node's settled value a journal row keeps.\n *\n * A node record is a small row beside the plan record's 12,000-byte page\n * budget, and it is written once per node of every graph: a value kept whole\n * would put an agent transcript in a permanent row and a projection would\n * clip it without saying so. Two kibibytes is enough to read what a node\n * produced and small enough that the settlement stays a summary.\n *\n * @since 0.1.0\n * @category constants\n */\nexport const maximumResultBytes = 2_048\n\n/**\n * How large a settled value may be before it is summarized at all.\n *\n * Redacting a value rebuilds every member of it and runs the textual rules\n * over every string, on the journal write path, for every node of every\n * graph. Past this ceiling the walk is the cost rather than the row, and the\n * honest answer is the size alone: the encoding is measured, `preview` is\n * empty, and `truncated` says the text was cut to nothing. Anything below it\n * is redacted whole and then cut.\n *\n * @since 0.1.0\n * @category constants\n */\nexport const maximumSummarizedBytes = 65_536\n\n/** The redactor a node summary is scrubbed with, built once. @private */\nconst redactor = Redaction.make({ onTooDeep: \"name\" })\n\n/** UTF-8 bytes of a string, without allocating the encoding. @private */\nconst utf8Bytes = (text: string): number => {\n  let bytes = 0\n  for (let index = 0; index < text.length; index++) {\n    const code = text.charCodeAt(index)\n    if (code < 0x80) bytes += 1\n    else if (code < 0x800) bytes += 2\n    else if (code >= 0xd800 && code <= 0xdbff && index + 1 < text.length) {\n      bytes += 4\n      index++\n    } else bytes += 3\n  }\n  return bytes\n}\n\n/**\n * The longest prefix of `text` within `limit` UTF-8 bytes, never splitting a\n * pair.\n *\n * One cut, taken where the walk stopped, because the walk stops for two\n * reasons and only one of them can happen: the caller asks only for text it\n * has already measured as over the limit, so a second exit for text that fits\n * whole would be a line no run reaches. @private\n */\nconst clampToBytes = (text: string, limit: number): string => {\n  let bytes = 0\n  let index = 0\n  while (index < text.length) {\n    const code = text.charCodeAt(index)\n    const pair = code >= 0xd800 && code <= 0xdbff && index + 1 < text.length\n    const size = code < 0x80 ? 1 : code < 0x800 ? 2 : pair ? 4 : 3\n    if (bytes + size > limit) break\n    bytes += size\n    index += pair ? 2 : 1\n  }\n  return text.slice(0, index)\n}\n\n/**\n * What a node settled with, redacted and then bounded.\n *\n * REDACTION COMES FIRST. `Redaction.redact` is the journal's own write-path\n * scrubber, and it is the one that reads a field NAME: `{ apiKey: \"sk-...\" }`\n * is a credential because of the key, which no rule over encoded text can see\n * once the value is a string inside a larger string. Running it over the\n * decoded value also collapses cycles and names functions, so the encoding\n * that follows always succeeds. Cutting the text first would be worse than\n * useless: a credential split across the boundary is a credential the textual\n * rules no longer recognise, and half of it would be kept.\n *\n * A value that will not encode even after redaction — a bigint, a value whose\n * own `toJSON` throws — gets no summary at all rather than a fabricated one.\n *\n * `bytes` is the size of the encoding `preview` was cut from, which for a\n * value past {@link maximumSummarizedBytes} is the value's own encoding: that\n * branch keeps nothing, so there is no second number to disagree with.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const resultSummary = (value: unknown): {\n  readonly preview: string\n  readonly bytes: number\n  readonly truncated: boolean\n} | undefined => {\n  // The size first, from the value's own encoding, because it is the cheap\n  // half: a value this row will not keep is named by its size and never\n  // walked. A value that will not encode at all — a cycle, a bigint, a\n  // throwing `toJSON` — says nothing here, and the redactor below is asked,\n  // because it collapses cycles and names what it cannot rewrite.\n  let raw: string | undefined\n  try {\n    raw = JSON.stringify(value)\n  } catch {\n    raw = undefined\n  }\n  if (raw !== undefined) {\n    const rawBytes = utf8Bytes(raw)\n    if (rawBytes > maximumSummarizedBytes) return { preview: \"\", bytes: rawBytes, truncated: true }\n  }\n  let encoded: string | undefined\n  try {\n    encoded = JSON.stringify(redactor(value))\n  } catch {\n    return undefined\n  }\n  if (encoded === undefined) return undefined\n  const bytes = utf8Bytes(encoded)\n  if (bytes > maximumSummarizedBytes) return { preview: \"\", bytes, truncated: true }\n  if (bytes <= maximumResultBytes) return { preview: encoded, bytes, truncated: false }\n  return { preview: clampToBytes(encoded, maximumResultBytes), bytes, truncated: true }\n}\n\n/**\n * The journal entry one node record is written as.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const entry = (scope: Scope, record: FlowRuntime.NodeRecord): JournalEvent.Input => {\n  const options = {\n    runId: scope.runId,\n    sourceId: `${scope.sourceId}/${record.sourceId}`,\n    lineageId: scope.lineageId,\n    // Without an explicit sequence the journal ALLOCATES the next one for the\n    // source, so a resumed walk would write a second row for every node it\n    // re-derived. Pinning it to zero makes the re-emission an exact producer\n    // retry, which is the whole of the exactly-once contract.\n    sourceSeq: 0,\n    // The sequence is derived from the record's own identity, so a collision\n    // is the same node observed twice rather than two nodes wearing one\n    // address. What differs between the observations is metadata ABOUT the\n    // observation — a node the first walk BUILT settles CLEAN on the walk\n    // that replayed it — and the first row, the one that says what actually\n    // happened, stands.\n    dedupe: \"identity\" as const\n  }\n  switch (record._tag) {\n    case \"PlanRecorded\":\n      return JournalRecords.planRecorded(options, {\n        flow: record.flow,\n        generation: record.generation,\n        // The node COUNT of the whole graph, which is what this field has\n        // always meant; the node LIST rides beside it as `graph`.\n        nodes: record.nodeCount,\n        page: record.page,\n        pages: record.pages,\n        graph: graph(scope, record)\n      })\n    case \"SubgraphAppended\":\n      return JournalRecords.subgraphAppended(options, {\n        flow: record.flow,\n        generation: record.generation,\n        nodeIds: record.nodes.map((node) => node.id),\n        page: record.page,\n        pages: record.pages,\n        graph: graph(scope, record)\n      })\n    case \"NodeScheduled\":\n      return JournalRecords.nodeScheduled(options, {\n        nodeId: record.nodeId,\n        kind: record.kind,\n        attempt: record.attempt,\n        ...(record.action === undefined ? {} : { action: record.action })\n      })\n    case \"NodeSettled\": {\n      const result = record.value === undefined ? undefined : resultSummary(record.value)\n      return JournalRecords.nodeSettled(options, {\n        nodeId: record.nodeId,\n        outcome: record.outcome,\n        attempts: record.attempts,\n        stepKeyDigests: record.stepKeyDigests,\n        ...(record.action === undefined ? {} : { action: record.action }),\n        ...(result === undefined ? {} : { result })\n      })\n    }\n  }\n}\n\n/**\n * UTF-8 upper bound for the durable entry, including allocated envelope fields.\n *\n * Sequence/time reserve their largest JSON encodings so page boundaries never\n * depend on the current journal position or clock, including after a resume.\n * @since 1.0.0\n * @category accessors\n */\nexport const encodedBytes = (scope: Scope, record: FlowRuntime.NodeRecord): number => {\n  const input = entry(scope, record)\n  const sourceSeq = JournalEvent.SourceSeq.make(0)\n  return new TextEncoder().encode(JSON.stringify({\n    runId: input.runId,\n    seq: Number.MAX_SAFE_INTEGER - 1,\n    eventId: JournalEvent.makeEventId(input.runId, input.sourceId, sourceSeq),\n    sourceId: input.sourceId,\n    sourceSeq,\n    emittedAtMs: Number.MAX_VALUE,\n    eventType: input.eventType,\n    payload: redactor(input.payload),\n    meta: redactor(input.meta)\n  })).byteLength\n}\n"]}

package/dist/esm/internal/Ordering.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Host-locale-independent UTF-16 code-unit ordering for durable material.
+ *
+ * @since 1.0.0
+ */
+/**
+ * Compares two strings by JavaScript's locale-independent UTF-16 relational
+ * order.
+ *
+ * @category ordering
+ * @since 1.0.0
+ */
+export declare const compareText: (left: string, right: string) => number;
+//# sourceMappingURL=Ordering.d.ts.map

package/dist/esm/internal/Ordering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ordering.d.ts","sourceRoot":"","sources":["../../../src/internal/Ordering.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,EAAE,OAAO,MAAM,KAAG,MAAkD,CAAA"}

package/dist/esm/internal/Ordering.js

@@ -0,0 +1,14 @@
+/**
+ * Host-locale-independent UTF-16 code-unit ordering for durable material.
+ *
+ * @since 1.0.0
+ */
+/**
+ * Compares two strings by JavaScript's locale-independent UTF-16 relational
+ * order.
+ *
+ * @category ordering
+ * @since 1.0.0
+ */
+export const compareText = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+//# sourceMappingURL=Ordering.js.map

package/dist/esm/internal/Ordering.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ordering.js","sourceRoot":"","sources":["../../../src/internal/Ordering.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,IAAY,EAAE,KAAa,EAAU,EAAE,CAAC,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA","sourcesContent":["/**\n * Host-locale-independent UTF-16 code-unit ordering for durable material.\n *\n * @since 1.0.0\n */\n\n/**\n * Compares two strings by JavaScript's locale-independent UTF-16 relational\n * order.\n *\n * @category ordering\n * @since 1.0.0\n */\nexport const compareText = (left: string, right: string): number => left < right ? -1 : left > right ? 1 : 0\n"]}

package/dist/esm/internal/PlanInputs.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Cross-check stored or newly measured observations against a verified plan.
+ * @since 1.0.0
+ */
+import { FileSet, type Plan } from "@smthrs/plan";
+import { Effect } from "effect";
+import * as PlanInputStore from "../PlanInputStore.ts";
+/**
+ * Validates without publishing or mutating either the old pins or observations.
+ * @since 1.0.0
+ * @category validation
+ */
+export declare const validate: (snapshot: PlanInputStore.Snapshot, nodes: ReadonlyArray<Plan.PlanNode>, pinned: ReadonlyMap<string, string>, writerScopesBefore: (node: Plan.PlanNode) => ReadonlyArray<FileSet.Entry>) => Effect.Effect<Map<string, string>, PlanInputStore.PlanInputError>;
+//# sourceMappingURL=PlanInputs.d.ts.map

package/dist/esm/internal/PlanInputs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlanInputs.d.ts","sourceRoot":"","sources":["../../../src/internal/PlanInputs.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,cAAc,CAAA;AACjD,OAAO,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAA;AACvC,OAAO,KAAK,cAAc,MAAM,sBAAsB,CAAA;AAEtD;;;;GAIG;AACH,eAAO,MAAM,QAAQ,GACnB,UAAU,cAAc,CAAC,QAAQ,EACjC,OAAO,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,EACnC,QAAQ,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACnC,oBAAoB,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,KAAK,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,KACxE,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,CAAC,cAAc,CA0C/D,CAAA"}