effect-agent 0.1.0-beta.85 → 0.1.0-beta.87

package/dist/durable/CommittedActivity.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CommittedActivity.mjs","names":[],"sources":["../../src/durable/CommittedActivity.ts"],"sourcesContent":["import { Clock, Effect, Schema, Stream, type Crypto, type Scope } from \"effect\";\n\nimport {\n  ActivityClaim,\n  ActivityClaimRequest,\n  ActivityProcessorKey,\n  ActivityProcessorStore,\n  PreparedActivity,\n  type ActivityStoreFailure,\n} from \"./ActivityStore.ts\";\nimport { digestJson, type DigestError } from \"./Digest.ts\";\nimport {\n  CanonicalRecordEnvelope,\n  CanonicalSequence,\n  PersistedJson,\n  RecordEnvelope,\n} from \"./Records.ts\";\nimport {\n  ThreadRead,\n  ThreadStore,\n  ThreadTail,\n  ThreadTailRequest,\n  type ThreadNotMaterialized,\n  type ThreadStoreError,\n} from \"./ThreadStore.ts\";\n\nexport class ActivityPassLimits extends Schema.Class<ActivityPassLimits>(\n  \"@effect-agent/thread/ActivityPassLimits\",\n)({\n  maxRecords: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 4_096 })),\n  pageSize: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 128 })),\n  timeoutMillis: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 300_000 })),\n  leaseMillis: ActivityClaimRequest.fields.leaseMillis,\n}) {}\n\nexport class ActivityProcessingError extends Schema.TaggedError<ActivityProcessingError>()(\n  \"ActivityProcessingError\",\n  {\n    reason: Schema.Literals([\"invalid-input\", \"noncontiguous\", \"timeout\"]),\n    message: Schema.String.check(Schema.isMaxLength(1_024)),\n  },\n) {}\n\nexport class ActivityPassResult extends Schema.Class<ActivityPassResult>(\n  \"@effect-agent/thread/ActivityPassResult\",\n)({\n  key: ActivityProcessorKey,\n  capturedTail: CanonicalSequence,\n  throughSequence: CanonicalSequence,\n  processed: Schema.Natural,\n  pendingRecords: Schema.Natural,\n  startedAt: Schema.Finite,\n  finishedAt: Schema.Finite,\n}) {}\n\nexport interface CommittedActivityProcessor<E = never, R = never, EApply = never, RApply = never> {\n  readonly key: ActivityProcessorKey;\n  /** Unique to this worker lifetime; it is not canonical Thread ownership. */\n  readonly owner: string;\n  readonly limits: ActivityPassLimits;\n  /** Select eligibility and encode an application Schema; null can represent no output. */\n  readonly extract: (record: CanonicalRecordEnvelope) => Effect.Effect<PersistedJson, E, R>;\n  /**\n   * Must durably reconcile workId before returning, using atomic idempotency and conditional\n   * writes. This may run again after any lost acknowledgement. A stale invocation can finish\n   * only the already pinned output; it must not overwrite a later correction or withdrawal.\n   * Retain reconciliation evidence for the lifetime of pending work, including any supported\n   * backup/restore window. Returning before durable application would permit skipped output.\n   */\n  readonly apply: (work: PreparedActivity) => Effect.Effect<void, EApply, RApply>;\n}\n\nconst invalid = (message: string) =>\n  ActivityProcessingError.make({ reason: \"invalid-input\", message });\n\nconst contiguous = () =>\n  ActivityProcessingError.make({\n    reason: \"noncontiguous\",\n    message: \"Committed activity does not match its captured Thread prefix or pinned record\",\n  });\n\n/** Stable work identity independent of worker claims, retry count, extraction, and clocks. */\nexport const activityWorkId = Effect.fn(\"activityWorkId\")(function* (\n  key: ActivityProcessorKey,\n  sequence: CanonicalSequence,\n) {\n  return yield* digestJson([\n    \"effect-agent/activity@1\",\n    key.processorId,\n    key.processorVersion,\n    key.threadId,\n    sequence,\n  ]);\n});\n\n/**\n * Process one bounded committed prefix of one application-selected Thread. Nothing runs until\n * invoked, and no daemon, global Thread directory, admission ledger, or engine checkpoint is\n * involved. PersistentHistory makes a successful Run's batch visible together; durable Runs\n * expose incremental committed records. The application decides what each record means.\n *\n * A durable pending output wins over a new extraction after restart. Apply finishes before\n * progress advances, so separate output stores require durable idempotency. This does not\n * promise exactly-once external side effects. Each callback owns a Scope; the finite pass has\n * a timeout and a longer lease. Claim release has a separate 500ms deadline; failure leaves\n * the bounded lease to expire.\n */\nexport const processCommittedActivity = Effect.fn(\"processCommittedActivity\")(function* <\n  E = never,\n  R = never,\n  EApply = never,\n  RApply = never,\n>(\n  processor: CommittedActivityProcessor<E, R, EApply, RApply>,\n): Effect.fn.Return<\n  ActivityPassResult,\n  | E\n  | EApply\n  | ActivityStoreFailure\n  | ActivityProcessingError\n  | DigestError\n  | ThreadStoreError\n  | ThreadNotMaterialized,\n  ActivityProcessorStore | ThreadStore | Crypto.Crypto | Exclude<R | RApply, Scope.Scope>\n> {\n  const key = yield* Schema.decodeEffect(ActivityProcessorKey)(processor.key).pipe(\n    Effect.mapError(() => invalid(\"Invalid activity processor key\")),\n  );\n\n  const limits = yield* Schema.decodeEffect(ActivityPassLimits)(processor.limits).pipe(\n    Effect.mapError(() => invalid(\"Invalid activity pass limits\")),\n  );\n\n  if (limits.leaseMillis < limits.timeoutMillis + 1_000) {\n    return yield* invalid(\"The activity lease must exceed the pass timeout by at least 1000ms\");\n  }\n\n  const request = yield* ActivityClaimRequest.makeEffect({\n    key,\n    owner: processor.owner,\n    leaseMillis: limits.leaseMillis,\n  }).pipe(Effect.mapError(() => invalid(\"Invalid activity worker identity\")));\n\n  const progress = yield* ActivityProcessorStore;\n  const threads = yield* ThreadStore;\n\n  return yield* Effect.scoped(\n    Effect.gen(function* () {\n      const acquired = yield* Effect.acquireRelease(\n        progress.claim(request).pipe(Effect.interruptible),\n        (claim) =>\n          progress\n            .release(claim)\n            .pipe(Effect.interruptible, Effect.timeoutOption(500), Effect.ignore),\n      );\n\n      let claim = yield* Schema.decodeEffect(ActivityClaim)(acquired).pipe(\n        Effect.mapError(() => invalid(\"Malformed activity claim\")),\n      );\n\n      if (\n        !Schema.toEquivalence(ActivityProcessorKey)(claim.key, key) ||\n        claim.owner !== request.owner\n      )\n        return yield* invalid(\"Activity claim identity does not match its request\");\n      const startedAt = yield* Clock.currentTimeMillis;\n\n      const tail = yield* threads\n        .inspectTail(ThreadTailRequest.make({ threadId: key.threadId }))\n        .pipe(\n          Effect.flatMap((value) =>\n            Schema.decodeEffect(ThreadTail)(value).pipe(Effect.mapError(contiguous)),\n          ),\n        );\n\n      if (\n        tail.threadId !== key.threadId ||\n        tail.tailSequence < claim.throughSequence ||\n        (claim.pending !== null && tail.tailSequence < claim.pending.sequence)\n      ) {\n        return yield* contiguous();\n      }\n      const through = Math.min(tail.tailSequence, claim.throughSequence + limits.maxRecords);\n      let processed = 0;\n\n      while (claim.throughSequence < through) {\n        const limit = Math.min(limits.pageSize, through - claim.throughSequence);\n\n        const page = yield* threads\n          .read(\n            ThreadRead.make({\n              threadId: key.threadId,\n              afterSequence: claim.throughSequence,\n              limit,\n            }),\n          )\n          .pipe(Stream.take(limit + 1), Stream.runCollect);\n\n        if (page.length !== limit) return yield* contiguous();\n        for (const rawRecord of page) {\n          const record = yield* Schema.decodeEffect(Schema.toType(CanonicalRecordEnvelope))(\n            rawRecord,\n          ).pipe(Effect.mapError(contiguous));\n\n          if (record.threadId !== key.threadId || record.sequence !== claim.throughSequence + 1) {\n            return yield* contiguous();\n          }\n          const workId = yield* activityWorkId(key, record.sequence);\n\n          const encodedRecord = yield* Schema.encodeEffect(RecordEnvelope)(record.record).pipe(\n            Effect.mapError(contiguous),\n          );\n\n          const recordDigest = yield* digestJson(encodedRecord);\n          let work = claim.pending;\n\n          if (work === null) {\n            const output = yield* Effect.scoped(processor.extract(record)).pipe(\n              Effect.flatMap((value) =>\n                Schema.decodeEffect(PersistedJson)(value).pipe(\n                  Effect.mapError(() => invalid(\"Malformed activity output\")),\n                ),\n              ),\n            );\n\n            work = yield* progress.prepare({\n              claim,\n              work: PreparedActivity.make({\n                version: 1,\n                key,\n                sequence: record.sequence,\n                workId,\n                recordId: record.record.recordId,\n                recordDigest,\n                output,\n              }),\n            });\n          }\n\n          const prepared = yield* Schema.decodeEffect(PreparedActivity)(work).pipe(\n            Effect.mapError(() => invalid(\"Malformed prepared activity\")),\n          );\n\n          if (\n            !Schema.toEquivalence(ActivityProcessorKey)(prepared.key, key) ||\n            prepared.sequence !== record.sequence ||\n            prepared.workId !== workId ||\n            prepared.recordId !== record.record.recordId ||\n            prepared.recordDigest !== recordDigest\n          )\n            return yield* contiguous();\n          yield* Effect.scoped(processor.apply(prepared));\n\n          const next = yield* progress\n            .advance({ claim, workId })\n            .pipe(\n              Effect.flatMap((value) =>\n                Schema.decodeEffect(ActivityClaim)(value).pipe(\n                  Effect.mapError(() => invalid(\"Malformed activity progress\")),\n                ),\n              ),\n            );\n\n          if (\n            !Schema.toEquivalence(ActivityProcessorKey)(next.key, key) ||\n            next.owner !== claim.owner ||\n            next.epoch !== claim.epoch ||\n            next.throughSequence !== record.sequence ||\n            next.pending !== null\n          )\n            return yield* invalid(\"Activity progress advanced outside the claimed record\");\n          claim = next;\n          processed += 1;\n        }\n      }\n\n      return ActivityPassResult.make({\n        key,\n        capturedTail: tail.tailSequence,\n        throughSequence: claim.throughSequence,\n        processed,\n        pendingRecords: tail.tailSequence - claim.throughSequence,\n        startedAt,\n        finishedAt: yield* Clock.currentTimeMillis,\n      });\n    }),\n  ).pipe(\n    Effect.timeoutOrElse({\n      duration: limits.timeoutMillis,\n      orElse: () =>\n        Effect.fail(\n          ActivityProcessingError.make({ reason: \"timeout\", message: \"Activity pass timed out\" }),\n        ),\n    }),\n  );\n});\n"],"mappings":"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"}

package/dist/durable/Digest.d.mts

@@ -0,0 +1,2 @@
+import { Gr as digestDefinition, Kr as digestDefinitions, Ur as EMPTY_TAIL_DIGEST, Vr as DigestError, Wr as digestCanonicalBatch, qr as digestJson } from "../Records-BAGkekt8.mjs";
+export { DigestError, EMPTY_TAIL_DIGEST, digestCanonicalBatch, digestDefinition, digestDefinitions, digestJson };

package/dist/durable/Digest.mjs

@@ -0,0 +1,50 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { CanonicalBatch, DefinitionDigests, Digest } from "./Records.mjs";
+import { Array, Crypto, Effect, Encoding, Schema } from "effect";
+//#region src/durable/Digest.ts
+var Digest_exports = /* @__PURE__ */ __exportAll({
+	DigestError: () => DigestError,
+	EMPTY_TAIL_DIGEST: () => EMPTY_TAIL_DIGEST,
+	digestCanonicalBatch: () => digestCanonicalBatch,
+	digestDefinition: () => digestDefinition,
+	digestDefinitions: () => digestDefinitions,
+	digestJson: () => digestJson
+});
+var DigestError = class extends Schema.TaggedError()("DigestError", {
+	message: Schema.String,
+	cause: Schema.optionalKey(Schema.Defect())
+}) {};
+const utf8 = new TextEncoder();
+const canonicalJson = (value) => {
+	if (value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${globalThis.Array.from(value, canonicalJson).join(",")}]`;
+	return `{${Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`).join(",")}}`;
+};
+/** Digest a JSON value using a stable, locale-independent object-key ordering (UTF-16 code units, RFC 8785 style). */
+const digestJson = Effect.fn("Thread.digestJson")(function* (value) {
+	const crypto = yield* Crypto.Crypto;
+	const bytes = utf8.encode(canonicalJson(value));
+	const digest = yield* crypto.digest("SHA-256", bytes).pipe(Effect.mapError((error) => DigestError.make({
+		message: `SHA-256 failed: ${error.message}`,
+		cause: error
+	})));
+	return yield* Schema.decodeEffect(Digest)(Encoding.encodeHex(digest)).pipe(Effect.mapError(() => DigestError.make({ message: "SHA-256 returned an invalid digest" })));
+});
+/** Digest a canonical batch together with the prior tail to form an append-only hash chain. */
+const digestCanonicalBatch = Effect.fn("Thread.digestCanonicalBatch")((previousTailDigest, batch) => Schema.encodeEffect(CanonicalBatch)(batch).pipe(Effect.mapError(() => DigestError.make({ message: "Canonical batch encoding failed" })), Effect.flatMap((encoded) => digestJson({
+	previousTailDigest,
+	batch: encoded
+}))));
+/** Digest one schema-encoded Agent, Model, or Toolkit definition. */
+const digestDefinition = Effect.fn("Thread.digestDefinition")((definition) => digestJson(definition));
+/** Digest all replay-relevant definitions without hiding which authority changed. */
+const digestDefinitions = Effect.fn("Thread.digestDefinitions")((definitions) => Effect.all({
+	agent: digestDefinition(definitions.agent),
+	model: digestDefinition(definitions.model),
+	tools: digestDefinition(definitions.tools)
+}).pipe(Effect.map((digests) => DefinitionDigests.make(digests))));
+const EMPTY_TAIL_DIGEST = Schema.decodeSync(Digest)("0000000000000000000000000000000000000000000000000000000000000000");
+//#endregion
+export { DigestError, EMPTY_TAIL_DIGEST, digestCanonicalBatch, digestDefinition, digestDefinitions, digestJson, Digest_exports as t };
+
+//# sourceMappingURL=Digest.mjs.map

package/dist/durable/Digest.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Digest.mjs","names":[],"sources":["../../src/durable/Digest.ts"],"sourcesContent":["import type { PlatformError } from \"effect\";\nimport { Array, Crypto, Effect, Encoding, Schema } from \"effect\";\n\nimport type { DefinitionDigestInput } from \"./Records.ts\";\nimport { CanonicalBatch, DefinitionDigests, Digest } from \"./Records.ts\";\n\nexport class DigestError extends Schema.TaggedError<DigestError>()(\"DigestError\", {\n  message: Schema.String,\n  cause: Schema.optionalKey(Schema.Defect()),\n}) {}\n\nconst utf8 = new TextEncoder();\n\nconst canonicalJson = (value: Schema.Json): string => {\n  if (\n    value === null ||\n    typeof value === \"boolean\" ||\n    typeof value === \"number\" ||\n    typeof value === \"string\"\n  ) {\n    return JSON.stringify(value);\n  }\n  if (Array.isArray<Schema.Json>(value)) {\n    return `[${globalThis.Array.from(value, canonicalJson).join(\",\")}]`;\n  }\n\n  const entries = Object.entries(value).sort(([left], [right]) =>\n    left < right ? -1 : left > right ? 1 : 0,\n  );\n\n  return `{${entries\n    .map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`)\n    .join(\",\")}}`;\n};\n\n/** Digest a JSON value using a stable, locale-independent object-key ordering (UTF-16 code units, RFC 8785 style). */\nexport const digestJson = Effect.fn(\"Thread.digestJson\")(function* (\n  value: Schema.Json,\n): Effect.fn.Return<Digest, DigestError, Crypto.Crypto> {\n  const crypto = yield* Crypto.Crypto;\n\n  const bytes = utf8.encode(canonicalJson(value));\n\n  const digest = yield* crypto\n    .digest(\"SHA-256\", bytes)\n    .pipe(\n      Effect.mapError((error: PlatformError.PlatformError) =>\n        DigestError.make({ message: `SHA-256 failed: ${error.message}`, cause: error }),\n      ),\n    );\n\n  return yield* Schema.decodeEffect(Digest)(Encoding.encodeHex(digest)).pipe(\n    Effect.mapError(() => DigestError.make({ message: \"SHA-256 returned an invalid digest\" })),\n  );\n});\n\n/** Digest a canonical batch together with the prior tail to form an append-only hash chain. */\nexport const digestCanonicalBatch = Effect.fn(\"Thread.digestCanonicalBatch\")(\n  (\n    previousTailDigest: Digest,\n    batch: CanonicalBatch,\n  ): Effect.Effect<Digest, DigestError, Crypto.Crypto> =>\n    Schema.encodeEffect(CanonicalBatch)(batch).pipe(\n      Effect.mapError(() => DigestError.make({ message: \"Canonical batch encoding failed\" })),\n      Effect.flatMap((encoded) =>\n        digestJson({\n          previousTailDigest,\n          batch: encoded,\n        }),\n      ),\n    ),\n);\n\n/** Digest one schema-encoded Agent, Model, or Toolkit definition. */\nexport const digestDefinition = Effect.fn(\"Thread.digestDefinition\")((definition: Schema.Json) =>\n  digestJson(definition),\n);\n\n/** Digest all replay-relevant definitions without hiding which authority changed. */\nexport const digestDefinitions = Effect.fn(\"Thread.digestDefinitions\")(\n  (\n    definitions: DefinitionDigestInput,\n  ): Effect.Effect<DefinitionDigests, DigestError, Crypto.Crypto> =>\n    Effect.all({\n      agent: digestDefinition(definitions.agent),\n      model: digestDefinition(definitions.model),\n      tools: digestDefinition(definitions.tools),\n    }).pipe(Effect.map((digests) => DefinitionDigests.make(digests))),\n);\n\nexport const EMPTY_TAIL_DIGEST = Schema.decodeSync(Digest)(\n  \"0000000000000000000000000000000000000000000000000000000000000000\",\n);\n"],"mappings":";;;;;;;;;;;;AAMA,IAAa,cAAb,cAAiC,OAAO,YAAyB,CAAC,CAAC,eAAe;CAChF,SAAS,OAAO;CAChB,OAAO,OAAO,YAAY,OAAO,OAAO,CAAC;AAC3C,CAAC,CAAC,CAAC,CAAC;AAEJ,MAAM,OAAO,IAAI,YAAY;AAE7B,MAAM,iBAAiB,UAA+B;CACpD,IACE,UAAU,QACV,OAAO,UAAU,aACjB,OAAO,UAAU,YACjB,OAAO,UAAU,UAEjB,OAAO,KAAK,UAAU,KAAK;CAE7B,IAAI,MAAM,QAAqB,KAAK,GAClC,OAAO,IAAI,WAAW,MAAM,KAAK,OAAO,aAAa,CAAC,CAAC,KAAK,GAAG,EAAE;CAOnE,OAAO,IAJS,OAAO,QAAQ,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,WACnD,OAAO,QAAQ,KAAK,OAAO,QAAQ,IAAI,CAGxB,CAAC,CACf,KAAK,CAAC,KAAK,WAAW,GAAG,KAAK,UAAU,GAAG,EAAE,GAAG,cAAc,KAAK,GAAG,CAAC,CACvE,KAAK,GAAG,EAAE;AACf;;AAGA,MAAa,aAAa,OAAO,GAAG,mBAAmB,CAAC,CAAC,WACvD,OACsD;CACtD,MAAM,SAAS,OAAO,OAAO;CAE7B,MAAM,QAAQ,KAAK,OAAO,cAAc,KAAK,CAAC;CAE9C,MAAM,SAAS,OAAO,OACnB,OAAO,WAAW,KAAK,CAAC,CACxB,KACC,OAAO,UAAU,UACf,YAAY,KAAK;EAAE,SAAS,mBAAmB,MAAM;EAAW,OAAO;CAAM,CAAC,CAChF,CACF;CAEF,OAAO,OAAO,OAAO,aAAa,MAAM,CAAC,CAAC,SAAS,UAAU,MAAM,CAAC,CAAC,CAAC,KACpE,OAAO,eAAe,YAAY,KAAK,EAAE,SAAS,qCAAqC,CAAC,CAAC,CAC3F;AACF,CAAC;;AAGD,MAAa,uBAAuB,OAAO,GAAG,6BAA6B,CAAC,EAExE,oBACA,UAEA,OAAO,aAAa,cAAc,CAAC,CAAC,KAAK,CAAC,CAAC,KACzC,OAAO,eAAe,YAAY,KAAK,EAAE,SAAS,kCAAkC,CAAC,CAAC,GACtF,OAAO,SAAS,YACd,WAAW;CACT;CACA,OAAO;AACT,CAAC,CACH,CACF,CACJ;;AAGA,MAAa,mBAAmB,OAAO,GAAG,yBAAyB,CAAC,EAAE,eACpE,WAAW,UAAU,CACvB;;AAGA,MAAa,oBAAoB,OAAO,GAAG,0BAA0B,CAAC,EAElE,gBAEA,OAAO,IAAI;CACT,OAAO,iBAAiB,YAAY,KAAK;CACzC,OAAO,iBAAiB,YAAY,KAAK;CACzC,OAAO,iBAAiB,YAAY,KAAK;AAC3C,CAAC,CAAC,CAAC,KAAK,OAAO,KAAK,YAAY,kBAAkB,KAAK,OAAO,CAAC,CAAC,CACpE;AAEA,MAAa,oBAAoB,OAAO,WAAW,MAAM,CAAC,CACxD,kEACF"}

package/dist/durable/DurableAgentRuntime.d.mts

@@ -0,0 +1,3 @@
+import { a as Receipt } from "../Receipt-BAHyigAF.mjs";
+import { At as DurableWorkerFailure, Ct as DurableRetryFailure, Dt as DurableSubmitFailure, Et as DurableSubmitAgent, Ft as recoveryRepairRecordId, It as threadCreatedBatchId, Lt as threadCreatedRecordId, Mt as RecoveryReport, Nt as childReservationIdFor, Ot as DurableSubmitOptions, Pt as recoveryRepairBatchId, St as DurableResolveFailure, Tt as DurableRuntimeConfigOptions, _t as DurableAwaitFailure, bt as DurableObserveOptions, ft as DurableAbortFailure, gt as DurableApprovalResolver, ht as DurableApprovalFailure, jt as DurableWorkerRequirements, kt as DurableVerifyFailure, pt as DurableAgentRuntime, vt as DurableExplainFailure, wt as DurableRuntimeConfig, xt as DurableProgressFailure, yt as DurableObligationFailure } from "../Records-BAGkekt8.mjs";
+export { DurableAbortFailure, DurableAgentRuntime, DurableApprovalFailure, DurableApprovalResolver, DurableAwaitFailure, DurableExplainFailure, DurableObligationFailure, DurableObserveOptions, DurableProgressFailure, DurableResolveFailure, DurableRetryFailure, DurableRuntimeConfig, DurableRuntimeConfigOptions, DurableSubmitAgent, DurableSubmitFailure, DurableSubmitOptions, DurableVerifyFailure, DurableWorkerFailure, DurableWorkerRequirements, Receipt, RecoveryReport, childReservationIdFor, recoveryRepairBatchId, recoveryRepairRecordId, threadCreatedBatchId, threadCreatedRecordId };

package/dist/durable/DurableAgentRuntime.mjs

@@ -0,0 +1,3 @@
+import { Receipt } from "../core/Receipt.mjs";
+import { a as RecoveryReport, c as recoveryRepairRecordId, i as DurableRuntimeConfig, l as threadCreatedBatchId, o as childReservationIdFor, r as DurableApprovalResolver, s as recoveryRepairBatchId, t as DurableAgentRuntime, u as threadCreatedRecordId } from "../DurableAgentRuntime-uggeJpv3.mjs";
+export { DurableAgentRuntime, DurableApprovalResolver, DurableRuntimeConfig, Receipt, RecoveryReport, childReservationIdFor, recoveryRepairBatchId, recoveryRepairRecordId, threadCreatedBatchId, threadCreatedRecordId };

package/dist/durable/DurableFailpoint.d.mts

@@ -0,0 +1,2 @@
+import { a as DurableRuntimeFailpointLocation, i as DurableRuntimeFailpointHandler, n as DurableRuntimeFailpoint, r as DurableRuntimeFailpointError } from "../DurableFailpoint-Oinuuedm.mjs";
+export { DurableRuntimeFailpoint, DurableRuntimeFailpointError, DurableRuntimeFailpointHandler, DurableRuntimeFailpointLocation };

package/dist/durable/DurableFailpoint.mjs

@@ -0,0 +1,94 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+//#region src/durable/DurableFailpoint.ts
+var DurableFailpoint_exports = /* @__PURE__ */ __exportAll({
+	DurableRuntimeFailpoint: () => DurableRuntimeFailpoint,
+	DurableRuntimeFailpointError: () => DurableRuntimeFailpointError,
+	DurableRuntimeFailpointLocation: () => DurableRuntimeFailpointLocation
+});
+/**
+* Coordinator-owned failpoint locations (plan §Failpoints). Locations normally sit immediately
+* AFTER one durable mutation of the six-step coordinator flow, so a fault injected there
+* simulates a crash between two durable steps; the matching BEFORE boundary of each mutation is
+* owned by the storage adapters (`ledger:*:before`, `append:before`, ...), giving every durable
+* mutation a failpoint on both sides (change discipline). Run-start append also exposes its
+* BEFORE boundary here to distinguish a fresh clock from a committed clock in crash tests.
+*
+* The `subagent:*` family covers every durable mutation of the S2 establishment/join protocol
+* including reservation, request append, child admission, child readiness,
+* start-link append, sibling per-call settles at the suspension seam, the `waitingForChild`
+* suspension, child abort propagation, the atomic join batch, and both reservation-release
+* transitions.
+*/
+const DurableRuntimeFailpointLocation = Schema.Literals([
+	"submit:after-admit",
+	"submit:after-materialize",
+	"claim:after-claim",
+	"input:after-canonical-append",
+	"run:before-start-append",
+	"run:after-start-append",
+	"turn:after-canonical-append",
+	"turn:after-response-append",
+	"turn:after-results-append",
+	"compaction:before-canonical-append",
+	"compaction:after-canonical-append",
+	"checkpoint:before-save",
+	"checkpoint:after-save",
+	"tools:after-prepared-append",
+	"tools:before-prepared-append",
+	"policy:before-reservation-append",
+	"policy:after-reservation-append",
+	"step:after-step-append",
+	"approval:after-request-append",
+	"approval:after-suspend",
+	"join:after-claim",
+	"join:after-canonical-append",
+	"resolve:after-intent",
+	"terminalize:after-reserve",
+	"terminalize:after-canonical-append",
+	"abort:after-intent",
+	"subagent:after-reserve",
+	"subagent:after-request-append",
+	"subagent:after-admit",
+	"subagent:after-child-ready",
+	"subagent:after-start-append",
+	"subagent:after-sibling-settle",
+	"subagent:after-suspend",
+	"subagent:after-child-abort-intent",
+	"subagent:before-join-append",
+	"subagent:after-join-append",
+	"subagent:after-release-pending",
+	"subagent:after-release",
+	"worker:before-source-append",
+	"worker:after-source-append",
+	"worker:before-origin-append",
+	"worker:after-origin-append",
+	"worker:before-completion-append",
+	"worker:after-completion-append",
+	"worker:before-subtree-append",
+	"worker:after-subtree-append",
+	"worker:before-report-append",
+	"worker:after-report-append",
+	"worker:before-report-delivery",
+	"worker:after-report-delivery",
+	"update:before-canonical-append",
+	"update:after-canonical-append",
+	"update:before-delivery-insert",
+	"update:after-delivery-insert"
+]);
+/** Injected coordinator fault. Reaching the caller means the preceding durable step committed. */
+var DurableRuntimeFailpointError = class extends Schema.TaggedError()("DurableRuntimeFailpointError", { location: DurableRuntimeFailpointLocation }) {};
+const noFailpoint = () => Effect.void;
+/**
+* Explicit fault-injection authority used at durable coordinator step boundaries. The process
+* crash harness (WP5) maps a hit to `process.exit`; in-process tests fail the step with the
+* typed `DurableRuntimeFailpointError` instead.
+*/
+var DurableRuntimeFailpoint = class extends Context.Service()("@effect-agent/thread/DurableRuntimeFailpoint") {
+	/** Production default: no fault injection. */
+	static layer = Layer.succeed(this)({ hit: noFailpoint });
+};
+//#endregion
+export { DurableRuntimeFailpoint, DurableRuntimeFailpointError, DurableRuntimeFailpointLocation, DurableFailpoint_exports as t };
+
+//# sourceMappingURL=DurableFailpoint.mjs.map

package/dist/durable/DurableFailpoint.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DurableFailpoint.mjs","names":[],"sources":["../../src/durable/DurableFailpoint.ts"],"sourcesContent":["import { Context, Effect, Layer, Schema } from \"effect\";\n\n/**\n * Coordinator-owned failpoint locations (plan §Failpoints). Locations normally sit immediately\n * AFTER one durable mutation of the six-step coordinator flow, so a fault injected there\n * simulates a crash between two durable steps; the matching BEFORE boundary of each mutation is\n * owned by the storage adapters (`ledger:*:before`, `append:before`, ...), giving every durable\n * mutation a failpoint on both sides (change discipline). Run-start append also exposes its\n * BEFORE boundary here to distinguish a fresh clock from a committed clock in crash tests.\n *\n * The `subagent:*` family covers every durable mutation of the S2 establishment/join protocol\n * including reservation, request append, child admission, child readiness,\n * start-link append, sibling per-call settles at the suspension seam, the `waitingForChild`\n * suspension, child abort propagation, the atomic join batch, and both reservation-release\n * transitions.\n */\nexport const DurableRuntimeFailpointLocation = Schema.Literals([\n  \"submit:after-admit\",\n  \"submit:after-materialize\",\n  \"claim:after-claim\",\n  \"input:after-canonical-append\",\n  \"run:before-start-append\",\n  \"run:after-start-append\",\n  \"turn:after-canonical-append\",\n  \"turn:after-response-append\",\n  \"turn:after-results-append\",\n  \"compaction:before-canonical-append\",\n  \"compaction:after-canonical-append\",\n  \"checkpoint:before-save\",\n  \"checkpoint:after-save\",\n  \"tools:after-prepared-append\",\n  \"tools:before-prepared-append\",\n  \"policy:before-reservation-append\",\n  \"policy:after-reservation-append\",\n  \"step:after-step-append\",\n  \"approval:after-request-append\",\n  \"approval:after-suspend\",\n  \"join:after-claim\",\n  \"join:after-canonical-append\",\n  \"resolve:after-intent\",\n  \"terminalize:after-reserve\",\n  \"terminalize:after-canonical-append\",\n  \"abort:after-intent\",\n  \"subagent:after-reserve\",\n  \"subagent:after-request-append\",\n  \"subagent:after-admit\",\n  \"subagent:after-child-ready\",\n  \"subagent:after-start-append\",\n  \"subagent:after-sibling-settle\",\n  \"subagent:after-suspend\",\n  \"subagent:after-child-abort-intent\",\n  \"subagent:before-join-append\",\n  \"subagent:after-join-append\",\n  \"subagent:after-release-pending\",\n  \"subagent:after-release\",\n  \"worker:before-source-append\",\n  \"worker:after-source-append\",\n  \"worker:before-origin-append\",\n  \"worker:after-origin-append\",\n  \"worker:before-completion-append\",\n  \"worker:after-completion-append\",\n  \"worker:before-subtree-append\",\n  \"worker:after-subtree-append\",\n  \"worker:before-report-append\",\n  \"worker:after-report-append\",\n  \"worker:before-report-delivery\",\n  \"worker:after-report-delivery\",\n  \"update:before-canonical-append\",\n  \"update:after-canonical-append\",\n  \"update:before-delivery-insert\",\n  \"update:after-delivery-insert\",\n]);\n\nexport type DurableRuntimeFailpointLocation = typeof DurableRuntimeFailpointLocation.Type;\n\n/** Injected coordinator fault. Reaching the caller means the preceding durable step committed. */\nexport class DurableRuntimeFailpointError extends Schema.TaggedError<DurableRuntimeFailpointError>()(\n  \"DurableRuntimeFailpointError\",\n  {\n    location: DurableRuntimeFailpointLocation,\n  },\n) {}\n\nexport type DurableRuntimeFailpointHandler = (\n  location: DurableRuntimeFailpointLocation,\n) => Effect.Effect<void, DurableRuntimeFailpointError>;\n\nconst noFailpoint: DurableRuntimeFailpointHandler = () => Effect.void;\n\n/**\n * Explicit fault-injection authority used at durable coordinator step boundaries. The process\n * crash harness (WP5) maps a hit to `process.exit`; in-process tests fail the step with the\n * typed `DurableRuntimeFailpointError` instead.\n */\nexport class DurableRuntimeFailpoint extends Context.Service<\n  DurableRuntimeFailpoint,\n  {\n    readonly hit: DurableRuntimeFailpointHandler;\n  }\n>()(\"@effect-agent/thread/DurableRuntimeFailpoint\") {\n  /** Production default: no fault injection. */\n  static readonly layer = Layer.succeed(this)({ hit: noFailpoint });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAgBA,MAAa,kCAAkC,OAAO,SAAS;CAC7D;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;;AAKD,IAAa,+BAAb,cAAkD,OAAO,YAA0C,CAAC,CAClG,gCACA,EACE,UAAU,gCACZ,CACF,CAAC,CAAC,CAAC;AAMH,MAAM,oBAAoD,OAAO;;;;;;AAOjE,IAAa,0BAAb,cAA6C,QAAQ,QAKnD,CAAC,CAAC,8CAA8C,CAAC,CAAC;;CAElD,OAAgB,QAAQ,MAAM,QAAQ,IAAI,CAAC,CAAC,EAAE,KAAK,YAAY,CAAC;AAClE"}

package/dist/durable/DurableFailpointTestControl.d.mts

@@ -0,0 +1,15 @@
+import { i as DurableRuntimeFailpointHandler, n as DurableRuntimeFailpoint } from "../DurableFailpoint-Oinuuedm.mjs";
+import { Context, Effect, Layer } from "effect";
+//#region src/durable/DurableFailpointTestControl.d.ts
+declare const DurableRuntimeFailpointTestControl_base: Context.ServiceClass<DurableRuntimeFailpointTestControl, "@effect-agent/thread/DurableRuntimeFailpointTestControl", {
+  readonly clear: Effect.Effect<void>;
+  readonly setHandler: (handler: DurableRuntimeFailpointHandler) => Effect.Effect<void>;
+}>;
+/** Test-only control for replacing the active coordinator failpoint handler. */
+declare class DurableRuntimeFailpointTestControl extends DurableRuntimeFailpointTestControl_base {
+  /** Reusable test Layer with a control service backed by the same handler Ref. */
+  static readonly layer: Layer.Layer<DurableRuntimeFailpoint | DurableRuntimeFailpointTestControl, never, never>;
+}
+//#endregion
+export { DurableRuntimeFailpointTestControl };
+//# sourceMappingURL=DurableFailpointTestControl.d.mts.map

package/dist/durable/DurableFailpointTestControl.mjs

@@ -0,0 +1,19 @@
+import { DurableRuntimeFailpoint } from "./DurableFailpoint.mjs";
+import { Context, Effect, Layer, Ref } from "effect";
+//#region src/durable/DurableFailpointTestControl.ts
+const noFailpoint = () => Effect.void;
+/** Test-only control for replacing the active coordinator failpoint handler. */
+var DurableRuntimeFailpointTestControl = class DurableRuntimeFailpointTestControl extends Context.Service()("@effect-agent/thread/DurableRuntimeFailpointTestControl") {
+	/** Reusable test Layer with a control service backed by the same handler Ref. */
+	static layer = Layer.effectContext(Effect.gen(function* () {
+		const handler = yield* Ref.make(noFailpoint);
+		return Context.make(DurableRuntimeFailpoint, DurableRuntimeFailpoint.of({ hit: (location) => Ref.get(handler).pipe(Effect.flatMap((current) => current(location))) })).pipe(Context.add(DurableRuntimeFailpointTestControl, DurableRuntimeFailpointTestControl.of({
+			clear: Ref.set(handler, noFailpoint),
+			setHandler: (next) => Ref.set(handler, next)
+		})));
+	}));
+};
+//#endregion
+export { DurableRuntimeFailpointTestControl };
+
+//# sourceMappingURL=DurableFailpointTestControl.mjs.map

package/dist/durable/DurableFailpointTestControl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DurableFailpointTestControl.mjs","names":[],"sources":["../../src/durable/DurableFailpointTestControl.ts"],"sourcesContent":["import { Context, Effect, Layer, Ref } from \"effect\";\n\nimport {\n  DurableRuntimeFailpoint,\n  type DurableRuntimeFailpointHandler,\n} from \"./DurableFailpoint.ts\";\n\nconst noFailpoint: DurableRuntimeFailpointHandler = () => Effect.void;\n\n/** Test-only control for replacing the active coordinator failpoint handler. */\nexport class DurableRuntimeFailpointTestControl extends Context.Service<\n  DurableRuntimeFailpointTestControl,\n  {\n    readonly clear: Effect.Effect<void>;\n    readonly setHandler: (handler: DurableRuntimeFailpointHandler) => Effect.Effect<void>;\n  }\n>()(\"@effect-agent/thread/DurableRuntimeFailpointTestControl\") {\n  /** Reusable test Layer with a control service backed by the same handler Ref. */\n  static readonly layer = Layer.effectContext(\n    Effect.gen(function* () {\n      const handler = yield* Ref.make<DurableRuntimeFailpointHandler>(noFailpoint);\n\n      return Context.make(\n        DurableRuntimeFailpoint,\n        DurableRuntimeFailpoint.of({\n          hit: (location) => Ref.get(handler).pipe(Effect.flatMap((current) => current(location))),\n        }),\n      ).pipe(\n        Context.add(\n          DurableRuntimeFailpointTestControl,\n          DurableRuntimeFailpointTestControl.of({\n            clear: Ref.set(handler, noFailpoint),\n            setHandler: (next) => Ref.set(handler, next),\n          }),\n        ),\n      );\n    }),\n  );\n}\n"],"mappings":";;;AAOA,MAAM,oBAAoD,OAAO;;AAGjE,IAAa,qCAAb,MAAa,2CAA2C,QAAQ,QAM9D,CAAC,CAAC,yDAAyD,CAAC,CAAC;;CAE7D,OAAgB,QAAQ,MAAM,cAC5B,OAAO,IAAI,aAAa;EACtB,MAAM,UAAU,OAAO,IAAI,KAAqC,WAAW;EAE3E,OAAO,QAAQ,KACb,yBACA,wBAAwB,GAAG,EACzB,MAAM,aAAa,IAAI,IAAI,OAAO,CAAC,CAAC,KAAK,OAAO,SAAS,YAAY,QAAQ,QAAQ,CAAC,CAAC,EACzF,CAAC,CACH,CAAC,CAAC,KACA,QAAQ,IACN,oCACA,mCAAmC,GAAG;GACpC,OAAO,IAAI,IAAI,SAAS,WAAW;GACnC,aAAa,SAAS,IAAI,IAAI,SAAS,IAAI;EAC7C,CAAC,CACH,CACF;CACF,CAAC,CACH;AACF"}

package/dist/durable/EventSource.d.mts

@@ -0,0 +1,2 @@
+import { a as makeEventSource, i as NormalizedEvent, r as EventSources, t as EventSource } from "../EventSource-OqS_P9ug.mjs";
+export { EventSource, EventSources, NormalizedEvent, makeEventSource };

package/dist/durable/EventSource.mjs

@@ -0,0 +1,65 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { PersistedJson } from "./Records.mjs";
+import { SubscriptionSourceError } from "./Subscription.mjs";
+import { Context, Effect, Schema } from "effect";
+//#region src/durable/EventSource.ts
+var EventSource_exports = /* @__PURE__ */ __exportAll({
+	EventSources: () => EventSources,
+	makeEventSource: () => makeEventSource
+});
+var EventSources = class extends Context.Service()("@effect-agent/thread/EventSources") {};
+const invalid = () => SubscriptionSourceError.make({
+	code: "source-schema",
+	retryable: false
+});
+/**
+* Capture the source's explicit Effect dependencies at host assembly. Matching and key functions
+* must be pure and bounded under this exact semantic version.
+* The returned source accepts Schema-encoded values at intake and management boundaries.
+* Each operation owns a fresh Scope for its callbacks and codecs; captured host services
+* retain their host lifetime. Operation resources finalize on success, failure, or interruption.
+*/
+const makeEventSource = Effect.fn("Thread.makeEventSource")(function* (options) {
+	const services = yield* Effect.context();
+	const encode = (schema, value) => Schema.encodeEffect(schema)(value).pipe(Effect.flatMap(Schema.decodeUnknownEffect(PersistedJson)), Effect.mapError(invalid));
+	const normalized = Effect.fn("EventSource.normalized")(function* (event) {
+		const occurredAtMillis = options.occurredAtMillis?.(event);
+		return {
+			eventId: options.identity(event),
+			...occurredAtMillis === void 0 ? {} : { occurredAtMillis },
+			matchingKey: options.eventKey(event),
+			payload: yield* encode(options.event, event)
+		};
+	});
+	const normalize = (value) => Schema.decodeUnknownEffect(PersistedJson)(value).pipe(Effect.flatMap(Schema.decodeUnknownEffect(options.event)), Effect.mapError(invalid), Effect.flatMap(normalized), Effect.scoped, Effect.provideContext(services));
+	const parameters = (value) => Effect.gen(function* () {
+		yield* Schema.decodeUnknownEffect(PersistedJson)(value).pipe(Effect.mapError(invalid));
+		const decoded = yield* Schema.decodeUnknownEffect(options.parameters)(value).pipe(Effect.mapError(invalid));
+		return {
+			parameters: yield* encode(options.parameters, decoded),
+			matchingKey: options.parameterKey(decoded)
+		};
+	}).pipe(Effect.scoped, Effect.provideContext(services));
+	const matches = (event, subscription) => Effect.gen(function* () {
+		const e = yield* Schema.decodeEffect(options.event)(event.payload).pipe(Effect.mapError(invalid));
+		const p = yield* Schema.decodeEffect(options.parameters)(subscription.configuration.parameters).pipe(Effect.mapError(invalid));
+		return options.matches(e, p);
+	}).pipe(Effect.scoped, Effect.provideContext(services));
+	const reconcile = options.reconcile;
+	return {
+		source: options.source,
+		continuity: options.continuity,
+		parameters,
+		normalize,
+		matches,
+		...reconcile === void 0 ? {} : { reconcile: (subscription) => Effect.gen(function* () {
+			const p = yield* Schema.decodeEffect(options.parameters)(subscription.configuration.parameters).pipe(Effect.mapError(invalid));
+			const event = yield* reconcile(p);
+			return event === null ? null : yield* normalized(event);
+		}).pipe(Effect.scoped, Effect.provideContext(services)) }
+	};
+});
+//#endregion
+export { EventSources, makeEventSource, EventSource_exports as t };
+
+//# sourceMappingURL=EventSource.mjs.map

package/dist/durable/EventSource.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventSource.mjs","names":[],"sources":["../../src/durable/EventSource.ts"],"sourcesContent":["import { Context, Effect, Schema, type Scope } from \"effect\";\n\nimport { PersistedJson } from \"./Records.ts\";\nimport {\n  type AcceptedEvent,\n  type EventSourceVersion,\n  type SubscriptionRecord,\n  SubscriptionSourceError,\n} from \"./Subscription.ts\";\n\nexport interface NormalizedEvent {\n  readonly eventId: string;\n  readonly occurredAtMillis?: number;\n  readonly matchingKey: string;\n  readonly payload: PersistedJson;\n}\n\n/** Runtime-only versioned behavior. Never persist this object or silently replace its version. */\nexport interface EventSource {\n  readonly source: EventSourceVersion;\n  readonly continuity: string;\n  readonly parameters: (\n    value: unknown,\n  ) => Effect.Effect<\n    { readonly parameters: PersistedJson; readonly matchingKey: string },\n    SubscriptionSourceError\n  >;\n  readonly normalize: (value: unknown) => Effect.Effect<NormalizedEvent, SubscriptionSourceError>;\n  readonly matches: (\n    event: AcceptedEvent,\n    subscription: SubscriptionRecord,\n  ) => Effect.Effect<boolean, SubscriptionSourceError>;\n  readonly reconcile?: (\n    subscription: SubscriptionRecord,\n  ) => Effect.Effect<NormalizedEvent | null, SubscriptionSourceError>;\n}\n\nexport class EventSources extends Context.Service<\n  EventSources,\n  {\n    readonly sources: ReadonlyArray<EventSource>;\n  }\n>()(\"@effect-agent/thread/EventSources\") {}\n\nconst invalid = () => SubscriptionSourceError.make({ code: \"source-schema\", retryable: false });\n\n/**\n * Capture the source's explicit Effect dependencies at host assembly. Matching and key functions\n * must be pure and bounded under this exact semantic version.\n * The returned source accepts Schema-encoded values at intake and management boundaries.\n * Each operation owns a fresh Scope for its callbacks and codecs; captured host services\n * retain their host lifetime. Operation resources finalize on success, failure, or interruption.\n */\nexport const makeEventSource = Effect.fn(\"Thread.makeEventSource\")(function* <\n  Event extends Schema.Top,\n  Parameters extends Schema.Top,\n  R = never,\n>(options: {\n  readonly source: EventSourceVersion;\n  readonly continuity: string;\n  readonly event: Event;\n  readonly parameters: Parameters;\n  readonly identity: (event: Event[\"Type\"]) => string;\n  /** Authenticated source time, stable across delivery retries; required for bounded retention. */\n  readonly occurredAtMillis?: (event: Event[\"Type\"]) => number | undefined;\n  readonly eventKey: (event: Event[\"Type\"]) => string;\n  readonly parameterKey: (parameters: Parameters[\"Type\"]) => string;\n  readonly matches: (event: Event[\"Type\"], parameters: Parameters[\"Type\"]) => boolean;\n  readonly reconcile?: (\n    parameters: Parameters[\"Type\"],\n  ) => Effect.Effect<Event[\"Type\"] | null, SubscriptionSourceError, R>;\n}): Effect.fn.Return<\n  EventSource,\n  never,\n  Exclude<\n    | R\n    | Event[\"DecodingServices\"]\n    | Event[\"EncodingServices\"]\n    | Parameters[\"DecodingServices\"]\n    | Parameters[\"EncodingServices\"],\n    Scope.Scope\n  >\n> {\n  const services =\n    yield* Effect.context<\n      Exclude<\n        | R\n        | Event[\"DecodingServices\"]\n        | Event[\"EncodingServices\"]\n        | Parameters[\"DecodingServices\"]\n        | Parameters[\"EncodingServices\"],\n        Scope.Scope\n      >\n    >();\n\n  const encode = <S extends Schema.Top>(schema: S, value: S[\"Type\"]) =>\n    Schema.encodeEffect(schema)(value).pipe(\n      Effect.flatMap(Schema.decodeUnknownEffect(PersistedJson)),\n      Effect.mapError(invalid),\n    );\n\n  const normalized = Effect.fn(\"EventSource.normalized\")(function* (event: Event[\"Type\"]) {\n    const occurredAtMillis = options.occurredAtMillis?.(event);\n\n    return {\n      eventId: options.identity(event),\n      ...(occurredAtMillis === undefined ? {} : { occurredAtMillis }),\n      matchingKey: options.eventKey(event),\n      payload: yield* encode(options.event, event),\n    };\n  });\n\n  const normalize: EventSource[\"normalize\"] = (value) =>\n    Schema.decodeUnknownEffect(PersistedJson)(value).pipe(\n      Effect.flatMap(Schema.decodeUnknownEffect(options.event)),\n      Effect.mapError(invalid),\n      Effect.flatMap(normalized),\n      Effect.scoped,\n      Effect.provideContext(services),\n    );\n\n  const parameters: EventSource[\"parameters\"] = (value) =>\n    Effect.gen(function* () {\n      yield* Schema.decodeUnknownEffect(PersistedJson)(value).pipe(Effect.mapError(invalid));\n\n      const decoded = yield* Schema.decodeUnknownEffect(options.parameters)(value).pipe(\n        Effect.mapError(invalid),\n      );\n\n      return {\n        parameters: yield* encode(options.parameters, decoded),\n        matchingKey: options.parameterKey(decoded),\n      };\n    }).pipe(Effect.scoped, Effect.provideContext(services));\n\n  const matches: EventSource[\"matches\"] = (event, subscription) =>\n    Effect.gen(function* () {\n      const e = yield* Schema.decodeEffect(options.event)(event.payload).pipe(\n        Effect.mapError(invalid),\n      );\n\n      const p = yield* Schema.decodeEffect(options.parameters)(\n        subscription.configuration.parameters,\n      ).pipe(Effect.mapError(invalid));\n\n      return options.matches(e, p);\n    }).pipe(Effect.scoped, Effect.provideContext(services));\n\n  const reconcile = options.reconcile;\n\n  return {\n    source: options.source,\n    continuity: options.continuity,\n    parameters,\n    normalize,\n    matches,\n    ...(reconcile === undefined\n      ? {}\n      : {\n          reconcile: (subscription: SubscriptionRecord) =>\n            Effect.gen(function* () {\n              const p = yield* Schema.decodeEffect(options.parameters)(\n                subscription.configuration.parameters,\n              ).pipe(Effect.mapError(invalid));\n\n              const event = yield* reconcile(p);\n\n              return event === null ? null : yield* normalized(event);\n            }).pipe(Effect.scoped, Effect.provideContext(services)),\n        }),\n  };\n});\n"],"mappings":";;;;;;;;;AAqCA,IAAa,eAAb,cAAkC,QAAQ,QAKxC,CAAC,CAAC,mCAAmC,CAAC,CAAC,CAAC;AAE1C,MAAM,gBAAgB,wBAAwB,KAAK;CAAE,MAAM;CAAiB,WAAW;AAAM,CAAC;;;;;;;;AAS9F,MAAa,kBAAkB,OAAO,GAAG,wBAAwB,CAAC,CAAC,WAIjE,SAyBA;CACA,MAAM,WACJ,OAAO,OAAO,QASZ;CAEJ,MAAM,UAAgC,QAAW,UAC/C,OAAO,aAAa,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,KACjC,OAAO,QAAQ,OAAO,oBAAoB,aAAa,CAAC,GACxD,OAAO,SAAS,OAAO,CACzB;CAEF,MAAM,aAAa,OAAO,GAAG,wBAAwB,CAAC,CAAC,WAAW,OAAsB;EACtF,MAAM,mBAAmB,QAAQ,mBAAmB,KAAK;EAEzD,OAAO;GACL,SAAS,QAAQ,SAAS,KAAK;GAC/B,GAAI,qBAAqB,KAAA,IAAY,CAAC,IAAI,EAAE,iBAAiB;GAC7D,aAAa,QAAQ,SAAS,KAAK;GACnC,SAAS,OAAO,OAAO,QAAQ,OAAO,KAAK;EAC7C;CACF,CAAC;CAED,MAAM,aAAuC,UAC3C,OAAO,oBAAoB,aAAa,CAAC,CAAC,KAAK,CAAC,CAAC,KAC/C,OAAO,QAAQ,OAAO,oBAAoB,QAAQ,KAAK,CAAC,GACxD,OAAO,SAAS,OAAO,GACvB,OAAO,QAAQ,UAAU,GACzB,OAAO,QACP,OAAO,eAAe,QAAQ,CAChC;CAEF,MAAM,cAAyC,UAC7C,OAAO,IAAI,aAAa;EACtB,OAAO,OAAO,oBAAoB,aAAa,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,OAAO,SAAS,OAAO,CAAC;EAErF,MAAM,UAAU,OAAO,OAAO,oBAAoB,QAAQ,UAAU,CAAC,CAAC,KAAK,CAAC,CAAC,KAC3E,OAAO,SAAS,OAAO,CACzB;EAEA,OAAO;GACL,YAAY,OAAO,OAAO,QAAQ,YAAY,OAAO;GACrD,aAAa,QAAQ,aAAa,OAAO;EAC3C;CACF,CAAC,CAAC,CAAC,KAAK,OAAO,QAAQ,OAAO,eAAe,QAAQ,CAAC;CAExD,MAAM,WAAmC,OAAO,iBAC9C,OAAO,IAAI,aAAa;EACtB,MAAM,IAAI,OAAO,OAAO,aAAa,QAAQ,KAAK,CAAC,CAAC,MAAM,OAAO,CAAC,CAAC,KACjE,OAAO,SAAS,OAAO,CACzB;EAEA,MAAM,IAAI,OAAO,OAAO,aAAa,QAAQ,UAAU,CAAC,CACtD,aAAa,cAAc,UAC7B,CAAC,CAAC,KAAK,OAAO,SAAS,OAAO,CAAC;EAE/B,OAAO,QAAQ,QAAQ,GAAG,CAAC;CAC7B,CAAC,CAAC,CAAC,KAAK,OAAO,QAAQ,OAAO,eAAe,QAAQ,CAAC;CAExD,MAAM,YAAY,QAAQ;CAE1B,OAAO;EACL,QAAQ,QAAQ;EAChB,YAAY,QAAQ;EACpB;EACA;EACA;EACA,GAAI,cAAc,KAAA,IACd,CAAC,IACD,EACE,YAAY,iBACV,OAAO,IAAI,aAAa;GACtB,MAAM,IAAI,OAAO,OAAO,aAAa,QAAQ,UAAU,CAAC,CACtD,aAAa,cAAc,UAC7B,CAAC,CAAC,KAAK,OAAO,SAAS,OAAO,CAAC;GAE/B,MAAM,QAAQ,OAAO,UAAU,CAAC;GAEhC,OAAO,UAAU,OAAO,OAAO,OAAO,WAAW,KAAK;EACxD,CAAC,CAAC,CAAC,KAAK,OAAO,QAAQ,OAAO,eAAe,QAAQ,CAAC,EAC1D;CACN;AACF,CAAC"}

package/dist/durable/GitHubWorkflowSource.d.mts

@@ -0,0 +1,144 @@
+import { r as Principal } from "../Receipt-BAHyigAF.mjs";
+import "../Records-BAGkekt8.mjs";
+import { E as SubscriptionSourceError } from "../Subscription-BEP8oQO5.mjs";
+import { t as EventSource } from "../EventSource-OqS_P9ug.mjs";
+import { SubscriptionFailure, SubscriptionIntake } from "./Subscriptions.mjs";
+import { Context, Effect, Layer, Redacted, Schema } from "effect";
+import { HttpClient } from "effect/unstable/http";
+//#region src/durable/GitHubWorkflowSource.d.ts
+/** One repository whose identity and credentials are selected by the host. */
+declare const GitHubRepository: Schema.Struct<{
+  readonly id: Schema.Int;
+  readonly owner: Schema.NonEmptyString;
+  readonly name: Schema.NonEmptyString;
+}>;
+type GitHubRepository = typeof GitHubRepository.Type;
+/** Exact workflow attempt requested by an Agent through a host-permitted source. */
+declare const GitHubWorkflowRunWatch: Schema.Struct<{
+  readonly runId: Schema.Int;
+  readonly attempt: Schema.Int;
+  readonly expectedHeadSha: Schema.String;
+}>;
+type GitHubWorkflowRunWatch = typeof GitHubWorkflowRunWatch.Type;
+/**
+ * Small canonical completion shared by webhook intake and REST reconciliation. Provider delivery
+ * IDs, URLs, actors, and mutable metadata are deliberately omitted from durable event identity.
+ */
+declare const GitHubWorkflowRunCompletion: Schema.Struct<{
+  readonly repositoryId: Schema.Int;
+  readonly runId: Schema.Int;
+  readonly attempt: Schema.Int;
+  readonly headSha: Schema.String;
+  readonly conclusion: Schema.NonEmptyString;
+}>;
+type GitHubWorkflowRunCompletion = typeof GitHubWorkflowRunCompletion.Type;
+declare const GitHubWorkflowRunWebhook: Schema.Struct<{
+  readonly action: Schema.Literal<"completed">;
+  readonly repository: Schema.Struct<{
+    readonly id: Schema.Int;
+  }>;
+  readonly workflow_run: Schema.Struct<{
+    readonly id: Schema.Int;
+    readonly run_attempt: Schema.Int;
+    readonly head_sha: Schema.String;
+    readonly status: Schema.NonEmptyString;
+    readonly conclusion: Schema.NullOr<Schema.NonEmptyString>;
+    readonly repository: Schema.Struct<{
+      readonly id: Schema.Int;
+    }>;
+  }>;
+}>;
+type GitHubWorkflowRunWebhook = typeof GitHubWorkflowRunWebhook.Type;
+declare const GitHubWorkflowRunAttempt: Schema.Struct<{
+  readonly id: Schema.Int;
+  readonly run_attempt: Schema.Int;
+  readonly head_sha: Schema.String;
+  readonly status: Schema.NonEmptyString;
+  readonly conclusion: Schema.NullOr<Schema.NonEmptyString>;
+  readonly repository: Schema.Struct<{
+    readonly id: Schema.Int;
+  }>;
+}>;
+type GitHubWorkflowRunAttempt = typeof GitHubWorkflowRunAttempt.Type;
+declare const GitHubWorkflowRunSourceVersion: {
+  readonly name: "github-workflow-run-completed";
+  readonly version: "1";
+};
+declare const GitHubWorkflowRunsError_base: Schema.Class<GitHubWorkflowRunsError, Schema.TaggedStruct<"GitHubWorkflowRunsError", {
+  readonly reason: Schema.Literals<readonly ["rate-limited", "unavailable", "unauthorized", "not-found", "invalid-response"]>;
+  readonly retryable: Schema.Boolean;
+}>, import("effect/Cause").YieldableError>;
+declare class GitHubWorkflowRunsError extends GitHubWorkflowRunsError_base {}
+interface GitHubWorkflowRunAttemptRequest {
+  readonly repository: GitHubRepository;
+  readonly runId: number;
+  readonly attempt: number;
+}
+declare const GitHubWorkflowRuns_base: Context.ServiceClass<GitHubWorkflowRuns, "@effect-agent/thread/GitHubWorkflowRuns", {
+  readonly getAttempt: (request: GitHubWorkflowRunAttemptRequest) => Effect.Effect<GitHubWorkflowRunAttempt, GitHubWorkflowRunsError>;
+}>;
+/**
+ * Credentialed, read-only GitHub boundary. Implementations must authorize the repository and read
+ * the exact attempt endpoint; the source never receives or persists a credential.
+ */
+declare class GitHubWorkflowRuns extends GitHubWorkflowRuns_base {}
+interface GitHubWorkflowRunsHttpOptions {
+  /** Repository this credentialed adapter is authorized to read. */
+  readonly repository: GitHubRepository;
+  readonly token: Redacted.Redacted<string>;
+  readonly apiUrl?: string | undefined;
+  readonly userAgent?: string | undefined;
+}
+/**
+ * GitHub REST adapter for `GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt}`.
+ * It performs one bounded read. Scheduling retries and backoff remain owned by SubscriptionDriver.
+ */
+declare const githubWorkflowRunsHttpLayer: (options: GitHubWorkflowRunsHttpOptions) => Layer.Layer<GitHubWorkflowRuns, GitHubWorkflowRunsError, HttpClient.HttpClient>;
+interface GitHubWorkflowRunSourceOptions {
+  readonly repository: GitHubRepository;
+}
+/**
+ * Build the exact-attempt completion source, shared by all destination Agents in this partition.
+ * Reconciliation depends on GitHub retaining a readable exact attempt.
+ */
+declare const makeGitHubWorkflowRunSource: (options: GitHubWorkflowRunSourceOptions) => Effect.Effect<EventSource, SubscriptionSourceError, GitHubWorkflowRuns>;
+declare const GitHubWebhookVerificationError_base: Schema.Class<GitHubWebhookVerificationError, Schema.TaggedStruct<"GitHubWebhookVerificationError", {
+  readonly reason: Schema.Literals<readonly ["invalid-signature", "invalid-event", "invalid-payload", "payload-too-large", "crypto-unavailable"]>;
+}>, import("effect/Cause").YieldableError>;
+declare class GitHubWebhookVerificationError extends GitHubWebhookVerificationError_base {}
+declare const GitHubWebhookSignatureVerifier_base: Context.ServiceClass<GitHubWebhookSignatureVerifier, "@effect-agent/thread/GitHubWebhookSignatureVerifier", {
+  readonly verify: (body: Uint8Array, signature: string) => Effect.Effect<void, GitHubWebhookVerificationError>;
+}>;
+/** Host-held webhook secret verification; callers cannot bypass it by supplying parsed JSON. */
+declare class GitHubWebhookSignatureVerifier extends GitHubWebhookSignatureVerifier_base {}
+/** Narrow host WebCrypto capability used for GitHub HMAC-SHA256 verification. */
+interface GitHubWebhookSubtleCrypto<Key> {
+  readonly importKey: (format: "raw", keyData: ArrayBuffer, algorithm: {
+    readonly name: "HMAC";
+    readonly hash: "SHA-256";
+  }, extractable: false, usages: ["verify"]) => PromiseLike<Key>;
+  readonly verify: (algorithm: "HMAC", key: Key, signature: ArrayBuffer, data: ArrayBuffer) => PromiseLike<boolean>;
+}
+/** GitHub-compatible HMAC-SHA256 verifier over the exact raw request bytes. */
+declare const webCryptoGitHubWebhookSignatureVerifierLayer: <Key>(secret: Redacted.Redacted<string>, subtle: GitHubWebhookSubtleCrypto<Key>) => Layer.Layer<GitHubWebhookSignatureVerifier>;
+interface VerifiedGitHubWorkflowRunWebhookRequest {
+  readonly body: Uint8Array;
+  readonly eventHeader: string | undefined;
+  readonly signatureHeader: string | undefined;
+  readonly principal: Principal;
+}
+/**
+ * Verify raw ingress, decode only a completed `workflow_run`, and hand its canonical completion to
+ * durable intake. The acknowledgement means routing work is retained; it is not a Submission Receipt.
+ */
+declare const acceptVerifiedGitHubWorkflowRunWebhook: (request: VerifiedGitHubWorkflowRunWebhookRequest) => Effect.Effect<{
+  readonly partition: {
+    readonly tenantId: string;
+    readonly address: string;
+  };
+  readonly eventId: string;
+  readonly acceptedAtMillis: number;
+}, GitHubWebhookVerificationError | SubscriptionFailure, GitHubWebhookSignatureVerifier | SubscriptionIntake>;
+//#endregion
+export { GitHubRepository, GitHubWebhookSignatureVerifier, GitHubWebhookSubtleCrypto, GitHubWebhookVerificationError, GitHubWorkflowRunAttempt, GitHubWorkflowRunAttemptRequest, GitHubWorkflowRunCompletion, GitHubWorkflowRunSourceOptions, GitHubWorkflowRunSourceVersion, GitHubWorkflowRunWatch, GitHubWorkflowRunWebhook, GitHubWorkflowRuns, GitHubWorkflowRunsError, GitHubWorkflowRunsHttpOptions, VerifiedGitHubWorkflowRunWebhookRequest, acceptVerifiedGitHubWorkflowRunWebhook, githubWorkflowRunsHttpLayer, makeGitHubWorkflowRunSource, webCryptoGitHubWebhookSignatureVerifierLayer };
+//# sourceMappingURL=GitHubWorkflowSource.d.mts.map