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

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

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

package/dist/cjs/EngineEvent.js

@@ -0,0 +1,383 @@
+"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 EngineEvent_exports = {};
+__export(EngineEvent_exports, {
+  AttemptLifecycle: () => AttemptLifecycle,
+  AttemptPayload: () => AttemptPayload,
+  CurrentAttempt: () => CurrentAttempt,
+  DeclaredAt: () => DeclaredAt,
+  EdgeSummary: () => EdgeSummary,
+  EventError: () => EventError,
+  ExecutionLifecycle: () => ExecutionLifecycle,
+  Failure: () => Failure,
+  Lineage: () => Lineage,
+  NodeGraph: () => NodeGraph,
+  NodeInvalidatedPayload: () => NodeInvalidatedPayload,
+  NodeReconciledPayload: () => NodeReconciledPayload,
+  NodeResultSummary: () => NodeResultSummary,
+  NodeScheduledPayload: () => NodeScheduledPayload,
+  NodeSettledPayload: () => NodeSettledPayload,
+  NodeSummary: () => NodeSummary,
+  PlanRecordedPayload: () => PlanRecordedPayload,
+  ResultEnvelope: () => ResultEnvelope,
+  SourceRevision: () => SourceRevision,
+  StatePayload: () => StatePayload,
+  SubgraphAppendedPayload: () => SubgraphAppendedPayload,
+  Success: () => Success,
+  Wait: () => Wait,
+  attempt: () => attempt,
+  attemptEventType: () => attemptEventType,
+  decodeCurrentAttempt: () => decodeCurrentAttempt,
+  decodeEntry: () => decodeEntry,
+  nodeEventTypes: () => nodeEventTypes,
+  relativePath: () => relativePath,
+  stateEvent: () => stateEvent,
+  stateEventType: () => stateEventType
+});
+module.exports = __toCommonJS(EngineEvent_exports);
+var Cause = __toESM(require("effect/Cause"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var Event = __toESM(require("./JournalEvent.js"), 1);
+const Lineage = Schema.Union([
+  Schema.Struct({
+    kind: Schema.Literal("root"),
+    runId: Event.RunId,
+    lineageId: Event.LineageId,
+    rootRunId: Event.RunId,
+    round: Schema.Literal(0),
+    parentRunId: Schema.Null
+  }).check(Schema.makeFilter((value) => value.runId === value.rootRunId)),
+  Schema.Struct({
+    kind: Schema.Literals(["child", "fork", "continuation"]),
+    runId: Event.RunId,
+    lineageId: Event.LineageId,
+    rootRunId: Event.RunId,
+    round: Event.NonNegativeQuantity,
+    parentRunId: Event.RunId
+  }).check(Schema.makeFilter(
+    (value) => value.runId !== value.parentRunId && value.runId !== value.rootRunId && (value.kind !== "continuation" || value.round > 0)
+  ))
+]);
+const Success = Schema.TaggedStruct("Success", { value: Schema.Json });
+const Failure = Schema.TaggedStruct("Failure", {
+  reason: Schema.Literals(["error", "defect", "interrupted", "encoding"]),
+  detail: Schema.Json
+});
+const ResultEnvelope = Schema.Union([Success, Failure]);
+const timing = { startedAtMs: Event.TimestampMs };
+const live = {
+  ...timing,
+  heartbeatAtMs: Schema.optionalKey(Event.TimestampMs),
+  checkpoint: Schema.optionalKey(Schema.Json),
+  finishedAtMs: Schema.optionalKey(Schema.Never),
+  result: Schema.optionalKey(Schema.Never)
+};
+const AttemptLifecycle = Schema.Union([
+  Schema.Struct({ state: Schema.Literal("running"), ...live }),
+  Schema.Struct({ state: Schema.Literal("suspended"), ...live }),
+  Schema.Struct({
+    state: Schema.Literal("succeeded"),
+    ...timing,
+    finishedAtMs: Event.TimestampMs,
+    result: Success
+  }),
+  Schema.Struct({
+    state: Schema.Literal("failed"),
+    ...timing,
+    finishedAtMs: Event.TimestampMs,
+    result: Failure
+  })
+]);
+const AttemptPayload = Schema.Struct({
+  version: Schema.Literal(2),
+  lineage: Lineage,
+  executionId: Event.RunId,
+  stepKeyDigest: Event.DispatchId,
+  attempt: Event.NonNegativeQuantity,
+  lifecycle: AttemptLifecycle
+}).check(Schema.makeFilter((value) => value.executionId === value.lineage.runId));
+const Wait = Schema.Union([
+  Schema.TaggedStruct("Deferred", { waitId: Event.WaitId }),
+  Schema.TaggedStruct("Clock", { waitId: Event.WaitId, dueAtMs: Event.TimestampMs })
+]);
+const ExecutionLifecycle = Schema.Union([
+  Schema.Struct({ state: Schema.Literal("running"), waits: Schema.Array(Wait) }),
+  Schema.Struct({ state: Schema.Literal("suspended"), waits: Schema.NonEmptyArray(Wait) }),
+  Schema.Struct({ state: Schema.Literal("completed"), result: ResultEnvelope })
+]);
+const StatePayload = Schema.Struct({
+  version: Schema.Literal(2),
+  lineage: Lineage,
+  executionId: Event.RunId,
+  event: Schema.Union([
+    Schema.TaggedStruct("Execution", { lifecycle: ExecutionLifecycle }),
+    Schema.TaggedStruct("DeferredCompleted", { waitId: Event.WaitId, result: ResultEnvelope }),
+    Schema.TaggedStruct("ClockScheduled", {
+      clockId: Event.CommandId,
+      waitId: Event.WaitId,
+      dueAtMs: Event.TimestampMs
+    })
+  ])
+}).check(Schema.makeFilter((value) => value.executionId === value.lineage.runId));
+const stateEventType = "flows.engine.v2.state-event";
+const attemptEventType = "flows.engine.v2.attempt-lifecycle";
+class EventError extends Schema.TaggedError()("@smthrs/journal/EngineEventError", {
+  code: Schema.Literals(["malformed", "unsupported", "foreign", "transition"]),
+  message: Schema.String,
+  cause: Schema.Unknown
+}) {
+}
+const strict = { onExcessProperty: "error" };
+const decodeRow = (input) => Effect.gen(function* () {
+  const raw = yield* Schema.decodeUnknownEffect(Schema.toEncoded(Event.Entry))(input);
+  return yield* Schema.decodeUnknownEffect(Event.Entry)(raw);
+});
+const decodePayload = Schema.decodeUnknownSync(AttemptPayload, strict);
+const decodeJson = Schema.decodeUnknownSync(Schema.Json);
+const decodeEntry = (input, consumer) => Effect.gen(function* () {
+  const entry = yield* decodeRow(input);
+  if (entry.runId !== consumer.runId || !consumer.sources.includes(entry.sourceId)) {
+    throw new EventError({
+      code: "foreign",
+      message: "event run or source is outside the consumer scope",
+      cause: entry
+    });
+  }
+  if (entry.eventType !== attemptEventType && entry.eventType !== stateEventType) {
+    if (entry.eventType.startsWith("flows.engine.")) {
+      throw new EventError({
+        code: "unsupported",
+        message: "unsupported engine event family or version",
+        cause: entry
+      });
+    }
+    return consumer.unknown === "ignore" ? { _tag: "Ignored" } : { _tag: "Unknown", entry };
+  }
+  const decoded = entry.eventType === attemptEventType ? { _tag: "Attempt", payload: yield* Schema.decodeUnknownEffect(AttemptPayload, strict)(entry.payload) } : { _tag: "State", payload: yield* Schema.decodeUnknownEffect(StatePayload, strict)(entry.payload) };
+  const { payload } = decoded;
+  if (payload.lineage.runId !== entry.runId || payload.lineage.lineageId !== consumer.lineageId || payload.lineage.rootRunId !== consumer.rootRunId || payload.lineage.round !== consumer.round || payload.lineage.parentRunId !== consumer.parentRunId) {
+    throw new EventError({
+      code: "foreign",
+      message: "event lineage disagrees with its journal or consumer",
+      cause: payload.lineage
+    });
+  }
+  yield* Schema.decodeUnknownEffect(Schema.Json)(entry.meta);
+  return { ...decoded, entry };
+}).pipe(Effect.catchCause((failure) => {
+  const cause = Cause.squash(failure);
+  return Effect.fail(
+    cause instanceof EventError ? cause : new EventError({ code: "malformed", message: "invalid engine event", cause })
+  );
+}));
+const attempt = (payload, sourceId, sourceSeq, diagnostics = null) => {
+  const validated = decodePayload(payload);
+  return new Event.Input({
+    runId: validated.lineage.runId,
+    sourceId,
+    sourceSeq,
+    eventType: attemptEventType,
+    payload: validated,
+    meta: decodeJson(diagnostics)
+  });
+};
+const stateEvent = (payload, sourceId, sourceSeq, diagnostics = null) => {
+  const validated = Schema.decodeUnknownSync(StatePayload, strict)(payload);
+  return new Event.Input({
+    runId: validated.lineage.runId,
+    sourceId,
+    sourceSeq,
+    eventType: stateEventType,
+    payload: validated,
+    meta: decodeJson(diagnostics)
+  });
+};
+const CurrentAttempt = Schema.Union([
+  Schema.Struct({
+    eventType: Schema.Literal("flows.engine.attempt-started"),
+    payload: Schema.Struct({
+      version: Schema.optionalKey(Schema.Never),
+      runId: Event.RunId,
+      stepKeyDigest: Event.DispatchId,
+      attempt: Event.NonNegativeQuantity,
+      tier: Schema.Literals(["sealed", "compensable", "irreversible"])
+    })
+  }),
+  Schema.Struct({
+    eventType: Schema.Literal("flows.engine.attempt-finished"),
+    payload: Schema.Struct({
+      version: Schema.optionalKey(Schema.Never),
+      runId: Event.RunId,
+      stepKeyDigest: Event.DispatchId,
+      attempt: Event.NonNegativeQuantity,
+      state: Schema.Literals(["succeeded", "failed"])
+    })
+  })
+]);
+const decodeCurrentAttempt = (input, consumer) => Effect.gen(function* () {
+  const entry = yield* decodeRow(input);
+  const marker = yield* Schema.decodeUnknownEffect(CurrentAttempt)(entry);
+  const meta = yield* Schema.decodeUnknownEffect(Schema.Struct({ lineageId: Event.LineageId }))(entry.meta);
+  if (entry.runId !== consumer.runId || marker.payload.runId !== entry.runId || meta.lineageId !== consumer.lineageId || !consumer.sources.includes(entry.sourceId)) {
+    throw new EventError({
+      code: "foreign",
+      message: "current attempt marker is outside the consumer scope",
+      cause: entry
+    });
+  }
+  return { entry, marker, lineageId: meta.lineageId };
+}).pipe(Effect.catchCause((failure) => {
+  const cause = Cause.squash(failure);
+  return Effect.fail(
+    cause instanceof EventError ? cause : new EventError({ code: "malformed", message: "invalid current attempt marker", cause })
+  );
+}));
+const DeclaredAt = Schema.Struct({
+  path: Schema.NonEmptyString.check(Schema.makeFilter((value) => !value.startsWith("/"))),
+  line: Event.NonNegativeQuantity
+});
+const isFilesystemRoot = (root) => root === "" || root === "/" || /^[A-Za-z]:[\\/]?$/.test(root);
+const relativePath = (root, path) => {
+  if (root === void 0 || isFilesystemRoot(root) || path === "") return void 0;
+  const base = root.endsWith("/") ? root : `${root}/`;
+  if (!path.startsWith(base)) return void 0;
+  const relative = path.slice(base.length);
+  return relative === "" ? void 0 : relative;
+};
+const NodeSummary = Schema.Struct({
+  id: Schema.NonEmptyString,
+  kind: Schema.String,
+  dependsOn: Schema.Array(Schema.NonEmptyString),
+  tier: Schema.Literals(["sealed", "compensable", "irreversible"]),
+  key: Schema.optionalKey(Schema.String),
+  generation: Schema.optionalKey(Event.NonNegativeQuantity),
+  action: Schema.optionalKey(Schema.String),
+  effects: Schema.optionalKey(Schema.Json),
+  declaredAt: Schema.optionalKey(DeclaredAt)
+});
+const EdgeSummary = Schema.Struct({
+  from: Schema.NonEmptyString,
+  to: Schema.NonEmptyString,
+  reason: Schema.Literals(["value", "continuation", "failure"])
+});
+const SourceRevision = Schema.NonEmptyString.check(Schema.makeFilter((value) => /^[0-9a-f]{40}$/.test(value)));
+const NodeGraph = Schema.Struct({
+  nodes: Schema.Array(NodeSummary),
+  edges: Schema.optionalKey(Schema.Array(EdgeSummary)),
+  /**
+   * The revision of the tree the nodes on this page were read out of.
+   *
+   * A `declaredAt` is a path and a line, and neither says which bytes were
+   * at that line: a working tree moves, so the same path after an edit or a
+   * branch switch is a different file. Only the writer can answer this —
+   * like the root a path is made relative to — so it travels with the page
+   * the sites travel on, and a reader can ask for the file AT this revision
+   * instead of whatever is on disk when they look.
+   *
+   * Optional because only a writer served out of a version-controlled tree
+   * can name one. A writer that cannot says nothing, and a reader that has
+   * nothing shows no code rather than code it cannot bind (D-068).
+   */
+  sourceRevision: Schema.optionalKey(SourceRevision)
+});
+const PlanRecordedPayload = Schema.Struct({
+  planId: Schema.optionalKey(Schema.NonEmptyString),
+  flow: Schema.NonEmptyString,
+  digest: Schema.optionalKey(Schema.String),
+  baseDigest: Schema.optionalKey(Schema.String),
+  generation: Event.NonNegativeQuantity,
+  nodes: Event.NonNegativeQuantity,
+  outcome: Schema.optionalKey(Schema.String),
+  page: Schema.optionalKey(Event.NonNegativeQuantity),
+  pages: Schema.optionalKey(Event.NonNegativeQuantity),
+  graph: Schema.optionalKey(NodeGraph)
+});
+const SubgraphAppendedPayload = Schema.Struct({
+  planId: Schema.optionalKey(Schema.NonEmptyString),
+  flow: Schema.optionalKey(Schema.NonEmptyString),
+  digest: Schema.optionalKey(Schema.String),
+  baseDigest: Schema.optionalKey(Schema.String),
+  generation: Event.NonNegativeQuantity,
+  nodeIds: Schema.Array(Schema.NonEmptyString),
+  page: Schema.optionalKey(Event.NonNegativeQuantity),
+  pages: Schema.optionalKey(Event.NonNegativeQuantity),
+  graph: Schema.optionalKey(NodeGraph)
+});
+const NodeScheduledPayload = Schema.Struct({
+  planId: Schema.optionalKey(Schema.NonEmptyString),
+  nodeId: Schema.NonEmptyString,
+  kind: Schema.String,
+  planKey: Schema.optionalKey(Schema.String),
+  dispatchKey: Schema.optionalKey(Schema.String),
+  attempt: Event.PositiveQuantity,
+  priority: Schema.optionalKey(Schema.Int),
+  waited: Schema.optionalKey(Event.NonNegativeQuantity),
+  action: Schema.optionalKey(Schema.String)
+});
+const NodeResultSummary = Schema.Struct({
+  preview: Schema.String,
+  bytes: Event.NonNegativeQuantity,
+  truncated: Schema.Boolean
+});
+const NodeSettledPayload = Schema.Struct({
+  planId: Schema.optionalKey(Schema.NonEmptyString),
+  nodeId: Schema.NonEmptyString,
+  planKey: Schema.optionalKey(Schema.String),
+  dispatchKey: Schema.optionalKey(Schema.String),
+  stepKeyDigests: Schema.optionalKey(Schema.Array(Schema.NonEmptyString)),
+  outcome: Schema.Literals(["built", "clean", "failed", "skipped", "deferred"]),
+  attempts: Event.NonNegativeQuantity,
+  rebases: Schema.optionalKey(Event.NonNegativeQuantity),
+  action: Schema.optionalKey(Schema.String),
+  result: Schema.optionalKey(NodeResultSummary)
+});
+const NodeInvalidatedPayload = Schema.Struct({
+  planId: Schema.NonEmptyString,
+  nodeId: Schema.NonEmptyString,
+  planKey: Schema.String,
+  from: Schema.String,
+  to: Schema.String,
+  reason: Schema.Literal("measured-inputs-changed")
+});
+const NodeReconciledPayload = Schema.Struct({
+  planId: Schema.NonEmptyString,
+  nodeId: Schema.NonEmptyString,
+  trigger: Schema.String,
+  verdict: Schema.Json
+});
+const nodeEventTypes = {
+  planRecorded: "flows.engine.plan-recorded",
+  subgraphAppended: "flows.engine.subgraph-appended",
+  nodeScheduled: "flows.engine.node-scheduled",
+  nodeSettled: "flows.engine.node-settled",
+  nodeInvalidated: "flows.engine.node-invalidated",
+  nodeReconciled: "flows.engine.node-reconciled"
+};
+//# sourceMappingURL=EngineEvent.js.map

package/dist/cjs/EngineEvent.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/EngineEvent.ts"],
+  "sourcesContent": ["/**\n * Versioned engine history contracts over the open journal. These schemas do\n * not change journal admission or make history the engine's recovery store.\n *\n * @since 1.0.0\n */\n\nimport * as Cause from \"effect/Cause\"\nimport * as Effect from \"effect/Effect\"\nimport * as Schema from \"effect/Schema\"\nimport * as Event from \"./JournalEvent.ts\"\n\n/**\n * Required lineage coordinates for a root or derived run.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Lineage = Schema.Union([\n  Schema.Struct({\n    kind: Schema.Literal(\"root\"),\n    runId: Event.RunId,\n    lineageId: Event.LineageId,\n    rootRunId: Event.RunId,\n    round: Schema.Literal(0),\n    parentRunId: Schema.Null\n  }).check(Schema.makeFilter((value) => value.runId === value.rootRunId)),\n  Schema.Struct({\n    kind: Schema.Literals([\"child\", \"fork\", \"continuation\"]),\n    runId: Event.RunId,\n    lineageId: Event.LineageId,\n    rootRunId: Event.RunId,\n    round: Event.NonNegativeQuantity,\n    parentRunId: Event.RunId\n  }).check(Schema.makeFilter((value) =>\n    value.runId !== value.parentRunId && value.runId !== value.rootRunId &&\n    (value.kind !== \"continuation\" || value.round > 0)\n  ))\n])\n\n/**\n * Required lineage coordinates for a root or derived run.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Lineage = typeof Lineage.Type\n\n/**\n * Encoded values only: class instances must first pass their own codec.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Success = Schema.TaggedStruct(\"Success\", { value: Schema.Json })\n\n/**\n * Failure channels stay distinct, including interruption and encoding failure.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Failure = Schema.TaggedStruct(\"Failure\", {\n  reason: Schema.Literals([\"error\", \"defect\", \"interrupted\", \"encoding\"]),\n  detail: Schema.Json\n})\n\n/**\n * Encoded success or a classified failure.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const ResultEnvelope = Schema.Union([Success, Failure])\n/**\n * Encoded success or a classified failure.\n *\n * @category models\n * @since 1.0.0\n */\nexport type ResultEnvelope = typeof ResultEnvelope.Type\n\nconst timing = { startedAtMs: Event.TimestampMs }\nconst live = {\n  ...timing,\n  heartbeatAtMs: Schema.optionalKey(Event.TimestampMs),\n  checkpoint: Schema.optionalKey(Schema.Json),\n  finishedAtMs: Schema.optionalKey(Schema.Never),\n  result: Schema.optionalKey(Schema.Never)\n}\n\n/**\n * Completion and its outcome are inseparable; live states cannot carry either.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const AttemptLifecycle = Schema.Union([\n  Schema.Struct({ state: Schema.Literal(\"running\"), ...live }),\n  Schema.Struct({ state: Schema.Literal(\"suspended\"), ...live }),\n  Schema.Struct({\n    state: Schema.Literal(\"succeeded\"),\n    ...timing,\n    finishedAtMs: Event.TimestampMs,\n    result: Success\n  }),\n  Schema.Struct({\n    state: Schema.Literal(\"failed\"),\n    ...timing,\n    finishedAtMs: Event.TimestampMs,\n    result: Failure\n  })\n])\n\n/**\n * Wall clocks can move backwards; completion need not be after start.\n *\n * @category models\n * @since 1.0.0\n */\nexport type AttemptLifecycle = typeof AttemptLifecycle.Type\n\n/**\n * Complete identity and state of one versioned attempt event.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const AttemptPayload = Schema.Struct({\n  version: Schema.Literal(2),\n  lineage: Lineage,\n  executionId: Event.RunId,\n  stepKeyDigest: Event.DispatchId,\n  attempt: Event.NonNegativeQuantity,\n  lifecycle: AttemptLifecycle\n}).check(Schema.makeFilter((value) => value.executionId === value.lineage.runId))\n\n/**\n * Complete identity and state of one versioned attempt event.\n *\n * @category models\n * @since 1.0.0\n */\nexport type AttemptPayload = typeof AttemptPayload.Type\n\n/**\n * Durable wait identities; ownership and cancellation remain independent facts.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Wait = Schema.Union([\n  Schema.TaggedStruct(\"Deferred\", { waitId: Event.WaitId }),\n  Schema.TaggedStruct(\"Clock\", { waitId: Event.WaitId, dueAtMs: Event.TimestampMs })\n])\n\n/**\n * A complete execution observation, without operational ownership leases.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const ExecutionLifecycle = Schema.Union([\n  Schema.Struct({ state: Schema.Literal(\"running\"), waits: Schema.Array(Wait) }),\n  Schema.Struct({ state: Schema.Literal(\"suspended\"), waits: Schema.NonEmptyArray(Wait) }),\n  Schema.Struct({ state: Schema.Literal(\"completed\"), result: ResultEnvelope })\n])\n\n/**\n * Versioned execution, deferred and clock observations. Every variant records\n * its semantic identity and encoded value independently of diagnostics.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const StatePayload = Schema.Struct({\n  version: Schema.Literal(2),\n  lineage: Lineage,\n  executionId: Event.RunId,\n  event: Schema.Union([\n    Schema.TaggedStruct(\"Execution\", { lifecycle: ExecutionLifecycle }),\n    Schema.TaggedStruct(\"DeferredCompleted\", { waitId: Event.WaitId, result: ResultEnvelope }),\n    Schema.TaggedStruct(\"ClockScheduled\", {\n      clockId: Event.CommandId,\n      waitId: Event.WaitId,\n      dueAtMs: Event.TimestampMs\n    })\n  ])\n}).check(Schema.makeFilter((value) => value.executionId === value.lineage.runId))\n\n/**\n * Versioned execution, deferred and clock observations.\n *\n * @category models\n * @since 1.0.0\n */\nexport type StatePayload = typeof StatePayload.Type\n\n/**\n * Event family for complete execution, deferred and clock observations.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const stateEventType = \"flows.engine.v2.state-event\"\n\n/**\n * New identity prevents old readers mistaking complete state for historical markers.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const attemptEventType = \"flows.engine.v2.attempt-lifecycle\"\n\n/**\n * Malformed, foreign, unsupported or inconsistent event evidence.\n *\n * @category errors\n * @since 1.0.0\n */\nexport class EventError extends Schema.TaggedError<EventError>()(\"@smthrs/journal/EngineEventError\", {\n  code: Schema.Literals([\"malformed\", \"unsupported\", \"foreign\", \"transition\"]),\n  message: Schema.String,\n  cause: Schema.Unknown\n}) {}\n\n/**\n * Every consumer chooses its source allowlist and unknown-namespace policy.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Consumer {\n  readonly runId: Event.RunId\n  readonly lineageId: Event.LineageId\n  readonly rootRunId: Event.RunId\n  readonly round: number\n  readonly parentRunId: Event.RunId | null\n  readonly sources: ReadonlyArray<Event.SourceId>\n  readonly unknown: \"ignore\" | \"surface\"\n}\n\n/**\n * A known event or the explicitly selected extension outcome.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Decoded =\n  | { readonly _tag: \"Attempt\"; readonly entry: Event.Entry; readonly payload: AttemptPayload }\n  | { readonly _tag: \"State\"; readonly entry: Event.Entry; readonly payload: StatePayload }\n  | { readonly _tag: \"Ignored\" }\n  | { readonly _tag: \"Unknown\"; readonly entry: Event.Entry }\n\nconst strict = { onExcessProperty: \"error\" } as const\nconst decodeRow = (input: unknown) =>\n  Effect.gen(function*() {\n    const raw = yield* Schema.decodeUnknownEffect(Schema.toEncoded(Event.Entry))(input)\n    return yield* Schema.decodeUnknownEffect(Event.Entry)(raw)\n  })\nconst decodePayload = Schema.decodeUnknownSync(AttemptPayload, strict)\nconst decodeJson = Schema.decodeUnknownSync(Schema.Json)\n\n/**\n * Decode untrusted committed input. Unknown events in the known engine namespace\n * are unsupported errors, never ignored. Original schema/accessor errors stay\n * in cause; foreign identity includes the conflicting evidence in cause.\n *\n * @category decoders\n * @since 1.0.0\n */\nexport const decodeEntry = (input: unknown, consumer: Consumer): Effect.Effect<Decoded, EventError> =>\n  Effect.gen(function*(): Effect.fn.Return<Decoded, unknown> {\n    const entry = yield* decodeRow(input)\n    if (entry.runId !== consumer.runId || !consumer.sources.includes(entry.sourceId)) {\n      throw new EventError({\n        code: \"foreign\",\n        message: \"event run or source is outside the consumer scope\",\n        cause: entry\n      })\n    }\n    if (entry.eventType !== attemptEventType && entry.eventType !== stateEventType) {\n      if (entry.eventType.startsWith(\"flows.engine.\")) {\n        throw new EventError({\n          code: \"unsupported\",\n          message: \"unsupported engine event family or version\",\n          cause: entry\n        })\n      }\n      return consumer.unknown === \"ignore\" ? { _tag: \"Ignored\" } : { _tag: \"Unknown\", entry }\n    }\n    const decoded = entry.eventType === attemptEventType\n      ? { _tag: \"Attempt\" as const, payload: yield* Schema.decodeUnknownEffect(AttemptPayload, strict)(entry.payload) }\n      : { _tag: \"State\" as const, payload: yield* Schema.decodeUnknownEffect(StatePayload, strict)(entry.payload) }\n    const { payload } = decoded\n    if (\n      payload.lineage.runId !== entry.runId || payload.lineage.lineageId !== consumer.lineageId ||\n      payload.lineage.rootRunId !== consumer.rootRunId || payload.lineage.round !== consumer.round ||\n      payload.lineage.parentRunId !== consumer.parentRunId\n    ) {\n      throw new EventError({\n        code: \"foreign\",\n        message: \"event lineage disagrees with its journal or consumer\",\n        cause: payload.lineage\n      })\n    }\n    // The optional journal side channel is disclosure only. Semantic lineage\n    // lives in payload and cannot be replaced by diagnostic metadata.\n    yield* Schema.decodeUnknownEffect(Schema.Json)(entry.meta)\n    return { ...decoded, entry }\n  }).pipe(Effect.catchCause((failure) => {\n    const cause = Cause.squash(failure)\n    return Effect.fail(\n      cause instanceof EventError\n        ? cause\n        : new EventError({ code: \"malformed\", message: \"invalid engine event\", cause })\n    )\n  }))\n\n/**\n * Construct a versioned submission, validating before journal redaction.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const attempt = (\n  payload: AttemptPayload,\n  sourceId: Event.SourceId,\n  sourceSeq: Event.SourceSeq,\n  diagnostics: Schema.Json = null\n): Event.Input => {\n  const validated = decodePayload(payload)\n  return new Event.Input({\n    runId: validated.lineage.runId,\n    sourceId,\n    sourceSeq,\n    eventType: attemptEventType,\n    payload: validated,\n    meta: decodeJson(diagnostics)\n  })\n}\n\n/**\n * Construct a versioned execution, deferred or clock submission. Existing\n * unversioned writers are unchanged and cannot manufacture missing lineage.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const stateEvent = (\n  payload: StatePayload,\n  sourceId: Event.SourceId,\n  sourceSeq: Event.SourceSeq,\n  diagnostics: Schema.Json = null\n): Event.Input => {\n  const validated = Schema.decodeUnknownSync(StatePayload, strict)(payload)\n  return new Event.Input({\n    runId: validated.lineage.runId,\n    sourceId,\n    sourceSeq,\n    eventType: stateEventType,\n    payload: validated,\n    meta: decodeJson(diagnostics)\n  })\n}\n\n/**\n * Historical attempt markers deliberately remain incomplete evidence. No\n * result, timestamp, round or lineage root is invented for old rows.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const CurrentAttempt = Schema.Union([\n  Schema.Struct({\n    eventType: Schema.Literal(\"flows.engine.attempt-started\"),\n    payload: Schema.Struct({\n      version: Schema.optionalKey(Schema.Never),\n      runId: Event.RunId,\n      stepKeyDigest: Event.DispatchId,\n      attempt: Event.NonNegativeQuantity,\n      tier: Schema.Literals([\"sealed\", \"compensable\", \"irreversible\"])\n    })\n  }),\n  Schema.Struct({\n    eventType: Schema.Literal(\"flows.engine.attempt-finished\"),\n    payload: Schema.Struct({\n      version: Schema.optionalKey(Schema.Never),\n      runId: Event.RunId,\n      stepKeyDigest: Event.DispatchId,\n      attempt: Event.NonNegativeQuantity,\n      state: Schema.Literals([\"succeeded\", \"failed\"])\n    })\n  })\n])\n\n/**\n * Decode current markers using their recorded lineage, without upgrading bytes.\n *\n * @category decoders\n * @since 1.0.0\n */\nexport const decodeCurrentAttempt = (input: unknown, consumer: Consumer) =>\n  Effect.gen(function*() {\n    const entry = yield* decodeRow(input)\n    const marker = yield* Schema.decodeUnknownEffect(CurrentAttempt)(entry)\n    const meta = yield* Schema.decodeUnknownEffect(Schema.Struct({ lineageId: Event.LineageId }))(entry.meta)\n    if (\n      entry.runId !== consumer.runId || marker.payload.runId !== entry.runId ||\n      meta.lineageId !== consumer.lineageId || !consumer.sources.includes(entry.sourceId)\n    ) {\n      throw new EventError({\n        code: \"foreign\",\n        message: \"current attempt marker is outside the consumer scope\",\n        cause: entry\n      })\n    }\n    return { entry, marker, lineageId: meta.lineageId }\n  }).pipe(Effect.catchCause((failure) => {\n    const cause = Cause.squash(failure)\n    return Effect.fail(\n      cause instanceof EventError\n        ? cause\n        : new EventError({ code: \"malformed\", message: \"invalid current attempt marker\", cause })\n    )\n  }))\n\n/**\n * Where a declaration was written, as a durable record may carry it.\n *\n * Repo-relative by contract: a journal is read on machines that are not the\n * one that wrote it, so an absolute path is at best noise and at worst an\n * operator's home directory published into a run's history. A writer that\n * cannot make a path relative omits the field.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const DeclaredAt = Schema.Struct({\n  path: Schema.NonEmptyString.check(Schema.makeFilter((value) => !value.startsWith(\"/\"))),\n  line: Event.NonNegativeQuantity\n})\n\n/**\n * A root that names the whole filesystem, which is no root at all.\n *\n * `process.cwd()` is `\"/\"` for a host a launcher started outside any\n * directory, and relativizing against it would make every absolute path\n * \"relative\": an operator's home directory, minus one leading slash, written\n * into a run's permanent history. The empty string is the same statement, and\n * a Windows drive root (`C:` or `C:\\`) is the same statement again. @private\n */\nconst isFilesystemRoot = (root: string): boolean => root === \"\" || root === \"/\" || /^[A-Za-z]:[\\\\/]?$/.test(root)\n\n/**\n * A declaration path as {@link DeclaredAt} may carry it: relative to the\n * root, or nothing.\n *\n * It lives beside the schema that refuses an absolute path, because obeying\n * that refusal is the writer's one job and every writer obeys it the same\n * way. A path outside the root is omitted rather than recorded with `..`\n * segments, because a reader resolving those would have to know the root,\n * which is exactly the machine-specific fact this strips. A root that is the\n * filesystem itself strips nothing, so it is read as no root.\n *\n * @category accessors\n * @since 1.0.0\n */\nexport const relativePath = (root: string | undefined, path: string): string | undefined => {\n  if (root === undefined || isFilesystemRoot(root) || path === \"\") return undefined\n  const base = root.endsWith(\"/\") ? root : `${root}/`\n  if (!path.startsWith(base)) return undefined\n  const relative = path.slice(base.length)\n  return relative === \"\" ? undefined : relative\n}\n\n/**\n * One node of the graph a run was driven from.\n *\n * `kind` is open text because the two executors name kinds differently and\n * both are true: the plan scheduler's node is a `step`, an `agent` or a\n * `merge`, while the interpreter's is the authoring variant it was observed\n * at. A closed union here would force one of them to lie.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const NodeSummary = Schema.Struct({\n  id: Schema.NonEmptyString,\n  kind: Schema.String,\n  dependsOn: Schema.Array(Schema.NonEmptyString),\n  tier: Schema.Literals([\"sealed\", \"compensable\", \"irreversible\"]),\n  key: Schema.optionalKey(Schema.String),\n  generation: Schema.optionalKey(Event.NonNegativeQuantity),\n  action: Schema.optionalKey(Schema.String),\n  effects: Schema.optionalKey(Schema.Json),\n  declaredAt: Schema.optionalKey(DeclaredAt)\n})\n\n/**\n * One edge of that graph, with the reason the builder drew it.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const EdgeSummary = Schema.Struct({\n  from: Schema.NonEmptyString,\n  to: Schema.NonEmptyString,\n  reason: Schema.Literals([\"value\", \"continuation\", \"failure\"])\n})\n\n/**\n * The immutable name of a tree a host read declaration sites out of.\n *\n * Exactly the forty lowercase hex digits the only producer emits: a jj\n * working-copy commit id, or a git commit for a tree that still matches one\n * (`SourceRevision.objectId`). It is narrowed here rather than left as text\n * because a reader puts it straight into a contents route's `?ref=`, and\n * `DeclaredAt` beside it refuses an absolute path for the same class of\n * reason: a field that only ever holds one shape should refuse the others at\n * the boundary rather than at whatever spawns a process downstream.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const SourceRevision = Schema.NonEmptyString.check(Schema.makeFilter((value) => /^[0-9a-f]{40}$/.test(value)))\n\n/**\n * The graph, or one page of it, carried beside a plan record.\n *\n * `edges` is optional because only one writer can answer it honestly. A plan\n * names its edges through each node's `dependsOn` and knows no reason for\n * them; an interpreter knows the reason it drew each one. A writer without\n * reasons omits the field rather than labelling every edge `value`.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const NodeGraph = Schema.Struct({\n  nodes: Schema.Array(NodeSummary),\n  edges: Schema.optionalKey(Schema.Array(EdgeSummary)),\n  /**\n   * The revision of the tree the nodes on this page were read out of.\n   *\n   * A `declaredAt` is a path and a line, and neither says which bytes were\n   * at that line: a working tree moves, so the same path after an edit or a\n   * branch switch is a different file. Only the writer can answer this \u2014\n   * like the root a path is made relative to \u2014 so it travels with the page\n   * the sites travel on, and a reader can ask for the file AT this revision\n   * instead of whatever is on disk when they look.\n   *\n   * Optional because only a writer served out of a version-controlled tree\n   * can name one. A writer that cannot says nothing, and a reader that has\n   * nothing shows no code rather than code it cannot bind (D-068).\n   */\n  sourceRevision: Schema.optionalKey(SourceRevision)\n})\n\n/**\n * A plan was recorded and a run is about to be driven under it.\n *\n * `nodes` is the node COUNT the record has always carried. The node list\n * arrives beside it as `graph`, optional and paged, because a journal entry\n * has a byte bound: what does not fit follows as {@link SubgraphAppended}\n * pages rather than being clipped.\n *\n * Everything an executor cannot honestly answer is optional rather than\n * invented. The interpreter drives a graph with no plan id, no plan digest\n * and no store to record an outcome with, and saying so is the point of this\n * schema.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const PlanRecordedPayload = Schema.Struct({\n  planId: Schema.optionalKey(Schema.NonEmptyString),\n  flow: Schema.NonEmptyString,\n  digest: Schema.optionalKey(Schema.String),\n  baseDigest: Schema.optionalKey(Schema.String),\n  generation: Event.NonNegativeQuantity,\n  nodes: Event.NonNegativeQuantity,\n  outcome: Schema.optionalKey(Schema.String),\n  page: Schema.optionalKey(Event.NonNegativeQuantity),\n  pages: Schema.optionalKey(Event.NonNegativeQuantity),\n  graph: Schema.optionalKey(NodeGraph)\n})\n\n/**\n * An elaboration appended a pre-keyed subgraph to the same plan, or the next\n * page of a graph too large for one record.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const SubgraphAppendedPayload = Schema.Struct({\n  planId: Schema.optionalKey(Schema.NonEmptyString),\n  flow: Schema.optionalKey(Schema.NonEmptyString),\n  digest: Schema.optionalKey(Schema.String),\n  baseDigest: Schema.optionalKey(Schema.String),\n  generation: Event.NonNegativeQuantity,\n  nodeIds: Schema.Array(Schema.NonEmptyString),\n  page: Schema.optionalKey(Event.NonNegativeQuantity),\n  pages: Schema.optionalKey(Event.NonNegativeQuantity),\n  graph: Schema.optionalKey(NodeGraph)\n})\n\n/**\n * A plan node was admitted and its work is about to start.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const NodeScheduledPayload = Schema.Struct({\n  planId: Schema.optionalKey(Schema.NonEmptyString),\n  nodeId: Schema.NonEmptyString,\n  kind: Schema.String,\n  planKey: Schema.optionalKey(Schema.String),\n  dispatchKey: Schema.optionalKey(Schema.String),\n  attempt: Event.PositiveQuantity,\n  priority: Schema.optionalKey(Schema.Int),\n  waited: Schema.optionalKey(Event.NonNegativeQuantity),\n  action: Schema.optionalKey(Schema.String)\n})\n\n/**\n * A bounded look at what a node settled with.\n *\n * `preview` is JSON text, redacted before it was encoded and cut to a fixed\n * ceiling afterwards, so a long value costs a durable row a known number of\n * bytes rather than however many it happens to hold. `truncated` says the cut\n * happened, which is also the warning that the text is a PREFIX of JSON and\n * no longer parses. `bytes` is the size of the encoding the preview was cut\n * from, so a reader can say how much was left out without being shown it; a\n * value too large for a writer to redact at all is named by the size of its\n * own encoding, with an empty preview and the flag set.\n *\n * Redaction comes first and truncation second on purpose: cutting the text\n * first can split a credential across the boundary, and a textual redactor\n * scanning the remains would no longer recognise it.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const NodeResultSummary = Schema.Struct({\n  preview: Schema.String,\n  bytes: Event.NonNegativeQuantity,\n  truncated: Schema.Boolean\n})\n\n/**\n * A plan node reached an outcome.\n *\n * The outcomes are Skyframe's evaluation states: `built` ran,\n * `clean` was served from records, `failed` raised, `skipped` was never\n * reached, and `deferred` is a scheduling debt the plan scheduler alone\n * records.\n *\n * `attempts` is the executor's own count. For the plan scheduler it is the\n * node's; for the interpreter it is the highest durable attempt any of this\n * node's dispatches ran as, because the interpreter settles each node once\n * and a retry happens underneath it inside one dispatch.\n *\n * `stepKeyDigests` names the dispatches the node drove, and it is the join\n * `flows.engine.attempt-started` could not make on its own: an attempt record\n * carries a step key digest and no node id, so an attempt belongs to the node\n * whose settlement claims its digest. A retried dispatch keeps ONE digest \u2014\n * the attempt is folded into no key \u2014 so the list is distinct dispatches, not\n * attempts. A writer that derives no digests omits the field; a node that\n * dispatched nothing records an empty list, which is a different statement.\n *\n * `result` is what the node settled with: the success value for `built` and\n * `clean`, the typed failure for `failed`, bounded and redacted by the writer.\n * Absent when the writer kept none.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const NodeSettledPayload = Schema.Struct({\n  planId: Schema.optionalKey(Schema.NonEmptyString),\n  nodeId: Schema.NonEmptyString,\n  planKey: Schema.optionalKey(Schema.String),\n  dispatchKey: Schema.optionalKey(Schema.String),\n  stepKeyDigests: Schema.optionalKey(Schema.Array(Schema.NonEmptyString)),\n  outcome: Schema.Literals([\"built\", \"clean\", \"failed\", \"skipped\", \"deferred\"]),\n  attempts: Event.NonNegativeQuantity,\n  rebases: Schema.optionalKey(Event.NonNegativeQuantity),\n  action: Schema.optionalKey(Schema.String),\n  result: Schema.optionalKey(NodeResultSummary)\n})\n\n/**\n * A scheduled node's dispatch identity was invalidated and re-keyed.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const NodeInvalidatedPayload = Schema.Struct({\n  planId: Schema.NonEmptyString,\n  nodeId: Schema.NonEmptyString,\n  planKey: Schema.String,\n  from: Schema.String,\n  to: Schema.String,\n  reason: Schema.Literal(\"measured-inputs-changed\")\n})\n\n/**\n * The reconciliation seam returned a verdict for a deviation.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const NodeReconciledPayload = Schema.Struct({\n  planId: Schema.NonEmptyString,\n  nodeId: Schema.NonEmptyString,\n  trigger: Schema.String,\n  verdict: Schema.Json\n})\n\n/**\n * Where a declaration was written, as a durable record carries it.\n *\n * @category models\n * @since 1.0.0\n */\nexport type DeclaredAt = typeof DeclaredAt.Type\n\n/**\n * One node of the graph a run was driven from.\n *\n * @category models\n * @since 1.0.0\n */\nexport type NodeSummary = typeof NodeSummary.Type\n\n/**\n * One edge of the graph a run was driven from.\n *\n * @category models\n * @since 1.0.0\n */\nexport type EdgeSummary = typeof EdgeSummary.Type\n\n/**\n * The graph, or one page of it, carried beside a plan record.\n *\n * @category models\n * @since 1.0.0\n */\nexport type NodeGraph = typeof NodeGraph.Type\n\n/**\n * A plan was recorded and a run is about to be driven under it.\n *\n * @category models\n * @since 1.0.0\n */\nexport type PlanRecordedPayload = typeof PlanRecordedPayload.Type\n\n/**\n * An elaboration appended a subgraph, or the next page of a large graph.\n *\n * @category models\n * @since 1.0.0\n */\nexport type SubgraphAppendedPayload = typeof SubgraphAppendedPayload.Type\n\n/**\n * A plan node was admitted and its work is about to start.\n *\n * @category models\n * @since 1.0.0\n */\nexport type NodeScheduledPayload = typeof NodeScheduledPayload.Type\n\n/**\n * A bounded look at what a node settled with.\n *\n * @category models\n * @since 1.0.0\n */\nexport type NodeResultSummary = typeof NodeResultSummary.Type\n\n/**\n * A plan node reached an outcome.\n *\n * @category models\n * @since 1.0.0\n */\nexport type NodeSettledPayload = typeof NodeSettledPayload.Type\n\n/**\n * A scheduled node's dispatch identity was invalidated and re-keyed.\n *\n * @category models\n * @since 1.0.0\n */\nexport type NodeInvalidatedPayload = typeof NodeInvalidatedPayload.Type\n\n/**\n * The reconciliation seam's verdict for one deviation.\n *\n * @category models\n * @since 1.0.0\n */\nexport type NodeReconciledPayload = typeof NodeReconciledPayload.Type\n\n/**\n * The event type each node and plan payload is recorded under.\n *\n * Readers and writers share these identities, so a value here is stored\n * history and changing one requires migrating it.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const nodeEventTypes = {\n  planRecorded: \"flows.engine.plan-recorded\",\n  subgraphAppended: \"flows.engine.subgraph-appended\",\n  nodeScheduled: \"flows.engine.node-scheduled\",\n  nodeSettled: \"flows.engine.node-settled\",\n  nodeInvalidated: \"flows.engine.node-invalidated\",\n  nodeReconciled: \"flows.engine.node-reconciled\"\n} as const\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,YAAuB;AACvB,aAAwB;AACxB,aAAwB;AACxB,YAAuB;AAQhB,MAAM,UAAU,OAAO,MAAM;AAAA,EAClC,OAAO,OAAO;AAAA,IACZ,MAAM,OAAO,QAAQ,MAAM;AAAA,IAC3B,OAAO,MAAM;AAAA,IACb,WAAW,MAAM;AAAA,IACjB,WAAW,MAAM;AAAA,IACjB,OAAO,OAAO,QAAQ,CAAC;AAAA,IACvB,aAAa,OAAO;AAAA,EACtB,CAAC,EAAE,MAAM,OAAO,WAAW,CAAC,UAAU,MAAM,UAAU,MAAM,SAAS,CAAC;AAAA,EACtE,OAAO,OAAO;AAAA,IACZ,MAAM,OAAO,SAAS,CAAC,SAAS,QAAQ,cAAc,CAAC;AAAA,IACvD,OAAO,MAAM;AAAA,IACb,WAAW,MAAM;AAAA,IACjB,WAAW,MAAM;AAAA,IACjB,OAAO,MAAM;AAAA,IACb,aAAa,MAAM;AAAA,EACrB,CAAC,EAAE,MAAM,OAAO;AAAA,IAAW,CAAC,UAC1B,MAAM,UAAU,MAAM,eAAe,MAAM,UAAU,MAAM,cAC1D,MAAM,SAAS,kBAAkB,MAAM,QAAQ;AAAA,EAClD,CAAC;AACH,CAAC;AAgBM,MAAM,UAAU,OAAO,aAAa,WAAW,EAAE,OAAO,OAAO,KAAK,CAAC;AAQrE,MAAM,UAAU,OAAO,aAAa,WAAW;AAAA,EACpD,QAAQ,OAAO,SAAS,CAAC,SAAS,UAAU,eAAe,UAAU,CAAC;AAAA,EACtE,QAAQ,OAAO;AACjB,CAAC;AAQM,MAAM,iBAAiB,OAAO,MAAM,CAAC,SAAS,OAAO,CAAC;AAS7D,MAAM,SAAS,EAAE,aAAa,MAAM,YAAY;AAChD,MAAM,OAAO;AAAA,EACX,GAAG;AAAA,EACH,eAAe,OAAO,YAAY,MAAM,WAAW;AAAA,EACnD,YAAY,OAAO,YAAY,OAAO,IAAI;AAAA,EAC1C,cAAc,OAAO,YAAY,OAAO,KAAK;AAAA,EAC7C,QAAQ,OAAO,YAAY,OAAO,KAAK;AACzC;AAQO,MAAM,mBAAmB,OAAO,MAAM;AAAA,EAC3C,OAAO,OAAO,EAAE,OAAO,OAAO,QAAQ,SAAS,GAAG,GAAG,KAAK,CAAC;AAAA,EAC3D,OAAO,OAAO,EAAE,OAAO,OAAO,QAAQ,WAAW,GAAG,GAAG,KAAK,CAAC;AAAA,EAC7D,OAAO,OAAO;AAAA,IACZ,OAAO,OAAO,QAAQ,WAAW;AAAA,IACjC,GAAG;AAAA,IACH,cAAc,MAAM;AAAA,IACpB,QAAQ;AAAA,EACV,CAAC;AAAA,EACD,OAAO,OAAO;AAAA,IACZ,OAAO,OAAO,QAAQ,QAAQ;AAAA,IAC9B,GAAG;AAAA,IACH,cAAc,MAAM;AAAA,IACpB,QAAQ;AAAA,EACV,CAAC;AACH,CAAC;AAgBM,MAAM,iBAAiB,OAAO,OAAO;AAAA,EAC1C,SAAS,OAAO,QAAQ,CAAC;AAAA,EACzB,SAAS;AAAA,EACT,aAAa,MAAM;AAAA,EACnB,eAAe,MAAM;AAAA,EACrB,SAAS,MAAM;AAAA,EACf,WAAW;AACb,CAAC,EAAE,MAAM,OAAO,WAAW,CAAC,UAAU,MAAM,gBAAgB,MAAM,QAAQ,KAAK,CAAC;AAgBzE,MAAM,OAAO,OAAO,MAAM;AAAA,EAC/B,OAAO,aAAa,YAAY,EAAE,QAAQ,MAAM,OAAO,CAAC;AAAA,EACxD,OAAO,aAAa,SAAS,EAAE,QAAQ,MAAM,QAAQ,SAAS,MAAM,YAAY,CAAC;AACnF,CAAC;AAQM,MAAM,qBAAqB,OAAO,MAAM;AAAA,EAC7C,OAAO,OAAO,EAAE,OAAO,OAAO,QAAQ,SAAS,GAAG,OAAO,OAAO,MAAM,IAAI,EAAE,CAAC;AAAA,EAC7E,OAAO,OAAO,EAAE,OAAO,OAAO,QAAQ,WAAW,GAAG,OAAO,OAAO,cAAc,IAAI,EAAE,CAAC;AAAA,EACvF,OAAO,OAAO,EAAE,OAAO,OAAO,QAAQ,WAAW,GAAG,QAAQ,eAAe,CAAC;AAC9E,CAAC;AASM,MAAM,eAAe,OAAO,OAAO;AAAA,EACxC,SAAS,OAAO,QAAQ,CAAC;AAAA,EACzB,SAAS;AAAA,EACT,aAAa,MAAM;AAAA,EACnB,OAAO,OAAO,MAAM;AAAA,IAClB,OAAO,aAAa,aAAa,EAAE,WAAW,mBAAmB,CAAC;AAAA,IAClE,OAAO,aAAa,qBAAqB,EAAE,QAAQ,MAAM,QAAQ,QAAQ,eAAe,CAAC;AAAA,IACzF,OAAO,aAAa,kBAAkB;AAAA,MACpC,SAAS,MAAM;AAAA,MACf,QAAQ,MAAM;AAAA,MACd,SAAS,MAAM;AAAA,IACjB,CAAC;AAAA,EACH,CAAC;AACH,CAAC,EAAE,MAAM,OAAO,WAAW,CAAC,UAAU,MAAM,gBAAgB,MAAM,QAAQ,KAAK,CAAC;AAgBzE,MAAM,iBAAiB;AAQvB,MAAM,mBAAmB;AAQzB,MAAM,mBAAmB,OAAO,YAAwB,EAAE,oCAAoC;AAAA,EACnG,MAAM,OAAO,SAAS,CAAC,aAAa,eAAe,WAAW,YAAY,CAAC;AAAA,EAC3E,SAAS,OAAO;AAAA,EAChB,OAAO,OAAO;AAChB,CAAC,EAAE;AAAC;AA8BJ,MAAM,SAAS,EAAE,kBAAkB,QAAQ;AAC3C,MAAM,YAAY,CAAC,UACjB,OAAO,IAAI,aAAY;AACrB,QAAM,MAAM,OAAO,OAAO,oBAAoB,OAAO,UAAU,MAAM,KAAK,CAAC,EAAE,KAAK;AAClF,SAAO,OAAO,OAAO,oBAAoB,MAAM,KAAK,EAAE,GAAG;AAC3D,CAAC;AACH,MAAM,gBAAgB,OAAO,kBAAkB,gBAAgB,MAAM;AACrE,MAAM,aAAa,OAAO,kBAAkB,OAAO,IAAI;AAUhD,MAAM,cAAc,CAAC,OAAgB,aAC1C,OAAO,IAAI,aAAgD;AACzD,QAAM,QAAQ,OAAO,UAAU,KAAK;AACpC,MAAI,MAAM,UAAU,SAAS,SAAS,CAAC,SAAS,QAAQ,SAAS,MAAM,QAAQ,GAAG;AAChF,UAAM,IAAI,WAAW;AAAA,MACnB,MAAM;AAAA,MACN,SAAS;AAAA,MACT,OAAO;AAAA,IACT,CAAC;AAAA,EACH;AACA,MAAI,MAAM,cAAc,oBAAoB,MAAM,cAAc,gBAAgB;AAC9E,QAAI,MAAM,UAAU,WAAW,eAAe,GAAG;AAC/C,YAAM,IAAI,WAAW;AAAA,QACnB,MAAM;AAAA,QACN,SAAS;AAAA,QACT,OAAO;AAAA,MACT,CAAC;AAAA,IACH;AACA,WAAO,SAAS,YAAY,WAAW,EAAE,MAAM,UAAU,IAAI,EAAE,MAAM,WAAW,MAAM;AAAA,EACxF;AACA,QAAM,UAAU,MAAM,cAAc,mBAChC,EAAE,MAAM,WAAoB,SAAS,OAAO,OAAO,oBAAoB,gBAAgB,MAAM,EAAE,MAAM,OAAO,EAAE,IAC9G,EAAE,MAAM,SAAkB,SAAS,OAAO,OAAO,oBAAoB,cAAc,MAAM,EAAE,MAAM,OAAO,EAAE;AAC9G,QAAM,EAAE,QAAQ,IAAI;AACpB,MACE,QAAQ,QAAQ,UAAU,MAAM,SAAS,QAAQ,QAAQ,cAAc,SAAS,aAChF,QAAQ,QAAQ,cAAc,SAAS,aAAa,QAAQ,QAAQ,UAAU,SAAS,SACvF,QAAQ,QAAQ,gBAAgB,SAAS,aACzC;AACA,UAAM,IAAI,WAAW;AAAA,MACnB,MAAM;AAAA,MACN,SAAS;AAAA,MACT,OAAO,QAAQ;AAAA,IACjB,CAAC;AAAA,EACH;AAGA,SAAO,OAAO,oBAAoB,OAAO,IAAI,EAAE,MAAM,IAAI;AACzD,SAAO,EAAE,GAAG,SAAS,MAAM;AAC7B,CAAC,EAAE,KAAK,OAAO,WAAW,CAAC,YAAY;AACrC,QAAM,QAAQ,MAAM,OAAO,OAAO;AAClC,SAAO,OAAO;AAAA,IACZ,iBAAiB,aACb,QACA,IAAI,WAAW,EAAE,MAAM,aAAa,SAAS,wBAAwB,MAAM,CAAC;AAAA,EAClF;AACF,CAAC,CAAC;AAQG,MAAM,UAAU,CACrB,SACA,UACA,WACA,cAA2B,SACX;AAChB,QAAM,YAAY,cAAc,OAAO;AACvC,SAAO,IAAI,MAAM,MAAM;AAAA,IACrB,OAAO,UAAU,QAAQ;AAAA,IACzB;AAAA,IACA;AAAA,IACA,WAAW;AAAA,IACX,SAAS;AAAA,IACT,MAAM,WAAW,WAAW;AAAA,EAC9B,CAAC;AACH;AASO,MAAM,aAAa,CACxB,SACA,UACA,WACA,cAA2B,SACX;AAChB,QAAM,YAAY,OAAO,kBAAkB,cAAc,MAAM,EAAE,OAAO;AACxE,SAAO,IAAI,MAAM,MAAM;AAAA,IACrB,OAAO,UAAU,QAAQ;AAAA,IACzB;AAAA,IACA;AAAA,IACA,WAAW;AAAA,IACX,SAAS;AAAA,IACT,MAAM,WAAW,WAAW;AAAA,EAC9B,CAAC;AACH;AASO,MAAM,iBAAiB,OAAO,MAAM;AAAA,EACzC,OAAO,OAAO;AAAA,IACZ,WAAW,OAAO,QAAQ,8BAA8B;AAAA,IACxD,SAAS,OAAO,OAAO;AAAA,MACrB,SAAS,OAAO,YAAY,OAAO,KAAK;AAAA,MACxC,OAAO,MAAM;AAAA,MACb,eAAe,MAAM;AAAA,MACrB,SAAS,MAAM;AAAA,MACf,MAAM,OAAO,SAAS,CAAC,UAAU,eAAe,cAAc,CAAC;AAAA,IACjE,CAAC;AAAA,EACH,CAAC;AAAA,EACD,OAAO,OAAO;AAAA,IACZ,WAAW,OAAO,QAAQ,+BAA+B;AAAA,IACzD,SAAS,OAAO,OAAO;AAAA,MACrB,SAAS,OAAO,YAAY,OAAO,KAAK;AAAA,MACxC,OAAO,MAAM;AAAA,MACb,eAAe,MAAM;AAAA,MACrB,SAAS,MAAM;AAAA,MACf,OAAO,OAAO,SAAS,CAAC,aAAa,QAAQ,CAAC;AAAA,IAChD,CAAC;AAAA,EACH,CAAC;AACH,CAAC;AAQM,MAAM,uBAAuB,CAAC,OAAgB,aACnD,OAAO,IAAI,aAAY;AACrB,QAAM,QAAQ,OAAO,UAAU,KAAK;AACpC,QAAM,SAAS,OAAO,OAAO,oBAAoB,cAAc,EAAE,KAAK;AACtE,QAAM,OAAO,OAAO,OAAO,oBAAoB,OAAO,OAAO,EAAE,WAAW,MAAM,UAAU,CAAC,CAAC,EAAE,MAAM,IAAI;AACxG,MACE,MAAM,UAAU,SAAS,SAAS,OAAO,QAAQ,UAAU,MAAM,SACjE,KAAK,cAAc,SAAS,aAAa,CAAC,SAAS,QAAQ,SAAS,MAAM,QAAQ,GAClF;AACA,UAAM,IAAI,WAAW;AAAA,MACnB,MAAM;AAAA,MACN,SAAS;AAAA,MACT,OAAO;AAAA,IACT,CAAC;AAAA,EACH;AACA,SAAO,EAAE,OAAO,QAAQ,WAAW,KAAK,UAAU;AACpD,CAAC,EAAE,KAAK,OAAO,WAAW,CAAC,YAAY;AACrC,QAAM,QAAQ,MAAM,OAAO,OAAO;AAClC,SAAO,OAAO;AAAA,IACZ,iBAAiB,aACb,QACA,IAAI,WAAW,EAAE,MAAM,aAAa,SAAS,kCAAkC,MAAM,CAAC;AAAA,EAC5F;AACF,CAAC,CAAC;AAaG,MAAM,aAAa,OAAO,OAAO;AAAA,EACtC,MAAM,OAAO,eAAe,MAAM,OAAO,WAAW,CAAC,UAAU,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC;AAAA,EACtF,MAAM,MAAM;AACd,CAAC;AAWD,MAAM,mBAAmB,CAAC,SAA0B,SAAS,MAAM,SAAS,OAAO,oBAAoB,KAAK,IAAI;AAgBzG,MAAM,eAAe,CAAC,MAA0B,SAAqC;AAC1F,MAAI,SAAS,UAAa,iBAAiB,IAAI,KAAK,SAAS,GAAI,QAAO;AACxE,QAAM,OAAO,KAAK,SAAS,GAAG,IAAI,OAAO,GAAG,IAAI;AAChD,MAAI,CAAC,KAAK,WAAW,IAAI,EAAG,QAAO;AACnC,QAAM,WAAW,KAAK,MAAM,KAAK,MAAM;AACvC,SAAO,aAAa,KAAK,SAAY;AACvC;AAaO,MAAM,cAAc,OAAO,OAAO;AAAA,EACvC,IAAI,OAAO;AAAA,EACX,MAAM,OAAO;AAAA,EACb,WAAW,OAAO,MAAM,OAAO,cAAc;AAAA,EAC7C,MAAM,OAAO,SAAS,CAAC,UAAU,eAAe,cAAc,CAAC;AAAA,EAC/D,KAAK,OAAO,YAAY,OAAO,MAAM;AAAA,EACrC,YAAY,OAAO,YAAY,MAAM,mBAAmB;AAAA,EACxD,QAAQ,OAAO,YAAY,OAAO,MAAM;AAAA,EACxC,SAAS,OAAO,YAAY,OAAO,IAAI;AAAA,EACvC,YAAY,OAAO,YAAY,UAAU;AAC3C,CAAC;AAQM,MAAM,cAAc,OAAO,OAAO;AAAA,EACvC,MAAM,OAAO;AAAA,EACb,IAAI,OAAO;AAAA,EACX,QAAQ,OAAO,SAAS,CAAC,SAAS,gBAAgB,SAAS,CAAC;AAC9D,CAAC;AAgBM,MAAM,iBAAiB,OAAO,eAAe,MAAM,OAAO,WAAW,CAAC,UAAU,iBAAiB,KAAK,KAAK,CAAC,CAAC;AAa7G,MAAM,YAAY,OAAO,OAAO;AAAA,EACrC,OAAO,OAAO,MAAM,WAAW;AAAA,EAC/B,OAAO,OAAO,YAAY,OAAO,MAAM,WAAW,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAenD,gBAAgB,OAAO,YAAY,cAAc;AACnD,CAAC;AAkBM,MAAM,sBAAsB,OAAO,OAAO;AAAA,EAC/C,QAAQ,OAAO,YAAY,OAAO,cAAc;AAAA,EAChD,MAAM,OAAO;AAAA,EACb,QAAQ,OAAO,YAAY,OAAO,MAAM;AAAA,EACxC,YAAY,OAAO,YAAY,OAAO,MAAM;AAAA,EAC5C,YAAY,MAAM;AAAA,EAClB,OAAO,MAAM;AAAA,EACb,SAAS,OAAO,YAAY,OAAO,MAAM;AAAA,EACzC,MAAM,OAAO,YAAY,MAAM,mBAAmB;AAAA,EAClD,OAAO,OAAO,YAAY,MAAM,mBAAmB;AAAA,EACnD,OAAO,OAAO,YAAY,SAAS;AACrC,CAAC;AASM,MAAM,0BAA0B,OAAO,OAAO;AAAA,EACnD,QAAQ,OAAO,YAAY,OAAO,cAAc;AAAA,EAChD,MAAM,OAAO,YAAY,OAAO,cAAc;AAAA,EAC9C,QAAQ,OAAO,YAAY,OAAO,MAAM;AAAA,EACxC,YAAY,OAAO,YAAY,OAAO,MAAM;AAAA,EAC5C,YAAY,MAAM;AAAA,EAClB,SAAS,OAAO,MAAM,OAAO,cAAc;AAAA,EAC3C,MAAM,OAAO,YAAY,MAAM,mBAAmB;AAAA,EAClD,OAAO,OAAO,YAAY,MAAM,mBAAmB;AAAA,EACnD,OAAO,OAAO,YAAY,SAAS;AACrC,CAAC;AAQM,MAAM,uBAAuB,OAAO,OAAO;AAAA,EAChD,QAAQ,OAAO,YAAY,OAAO,cAAc;AAAA,EAChD,QAAQ,OAAO;AAAA,EACf,MAAM,OAAO;AAAA,EACb,SAAS,OAAO,YAAY,OAAO,MAAM;AAAA,EACzC,aAAa,OAAO,YAAY,OAAO,MAAM;AAAA,EAC7C,SAAS,MAAM;AAAA,EACf,UAAU,OAAO,YAAY,OAAO,GAAG;AAAA,EACvC,QAAQ,OAAO,YAAY,MAAM,mBAAmB;AAAA,EACpD,QAAQ,OAAO,YAAY,OAAO,MAAM;AAC1C,CAAC;AAqBM,MAAM,oBAAoB,OAAO,OAAO;AAAA,EAC7C,SAAS,OAAO;AAAA,EAChB,OAAO,MAAM;AAAA,EACb,WAAW,OAAO;AACpB,CAAC;AA8BM,MAAM,qBAAqB,OAAO,OAAO;AAAA,EAC9C,QAAQ,OAAO,YAAY,OAAO,cAAc;AAAA,EAChD,QAAQ,OAAO;AAAA,EACf,SAAS,OAAO,YAAY,OAAO,MAAM;AAAA,EACzC,aAAa,OAAO,YAAY,OAAO,MAAM;AAAA,EAC7C,gBAAgB,OAAO,YAAY,OAAO,MAAM,OAAO,cAAc,CAAC;AAAA,EACtE,SAAS,OAAO,SAAS,CAAC,SAAS,SAAS,UAAU,WAAW,UAAU,CAAC;AAAA,EAC5E,UAAU,MAAM;AAAA,EAChB,SAAS,OAAO,YAAY,MAAM,mBAAmB;AAAA,EACrD,QAAQ,OAAO,YAAY,OAAO,MAAM;AAAA,EACxC,QAAQ,OAAO,YAAY,iBAAiB;AAC9C,CAAC;AAQM,MAAM,yBAAyB,OAAO,OAAO;AAAA,EAClD,QAAQ,OAAO;AAAA,EACf,QAAQ,OAAO;AAAA,EACf,SAAS,OAAO;AAAA,EAChB,MAAM,OAAO;AAAA,EACb,IAAI,OAAO;AAAA,EACX,QAAQ,OAAO,QAAQ,yBAAyB;AAClD,CAAC;AAQM,MAAM,wBAAwB,OAAO,OAAO;AAAA,EACjD,QAAQ,OAAO;AAAA,EACf,QAAQ,OAAO;AAAA,EACf,SAAS,OAAO;AAAA,EAChB,SAAS,OAAO;AAClB,CAAC;AAmGM,MAAM,iBAAiB;AAAA,EAC5B,cAAc;AAAA,EACd,kBAAkB;AAAA,EAClB,eAAe;AAAA,EACf,aAAa;AAAA,EACb,iBAAiB;AAAA,EACjB,gBAAgB;AAClB;",
+  "names": []
+}