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

package/dist/durable/ThreadProjectionMaintenance.d.mts

@@ -0,0 +1,49 @@
+import { Ht as FencedAppendRequest, zt as AppendResult } from "../Records-BAGkekt8.mjs";
+import { Context, Effect, Layer, Option, Schema } from "effect";
+declare namespace ThreadProjectionMaintenance_d_exports {
+  export { ThreadProjectionError, ThreadProjectionMaintenance, ThreadProjectionMaintenanceService, drainDue };
+}
+declare const ThreadProjectionError_base: Schema.Class<ThreadProjectionError, Schema.TaggedStruct<"ThreadProjectionError", {
+  readonly operation: Schema.String;
+  readonly message: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** A derived projection failed; the canonical source remains authoritative. */
+declare class ThreadProjectionError extends ThreadProjectionError_base {}
+/**
+ * Host-owned, disposable indexes over a canonical Thread. Hooks receive raw local source
+ * ports at construction and must not mutate them or acquire source producer ownership.
+ * Rows and their contiguous watermark commit atomically; an empty projection still consumes
+ * its record. Concurrent work must compare the starting watermark before committing.
+ *
+ * No method owns a scheduler. The platform owns wakeups, durable scheduling metadata and
+ * source-producer fencing. Per-call resources belong to Scope; interruption remains interruption.
+ */
+interface ThreadProjectionMaintenanceService {
+  /**
+   * Runs after a successful source commit and before dependent Tools can execute. An index
+   * caught up through firstSequence - 1 must process the entire committed range, including
+   * empty records, before returning. Canonical batches contain at most 256 records: chunk
+   * within local byte limits and stop at result.lastSequence, never chase a changing tail.
+   * An earlier gap defers to drain. Replayed or superseded ranges are idempotent no-ops.
+   * Failure must leave the unprocessed prefix visible to pendingDeadline.
+   */
+  readonly applyCommitted: (request: FencedAppendRequest, result: AppendResult) => Effect.Effect<void, ThreadProjectionError>;
+  /** One bounded, restartable backfill batch. Never drain until caught up in a loop. */
+  readonly drain: Effect.Effect<void, ThreadProjectionError>;
+  /**
+   * Bounded local inspection. None means caught up; a pending epoch-millisecond deadline
+   * survives reconstruction and repeated reads must not postpone it. Projection backlog
+   * does not gate canonical execution or host approval publication.
+   */
+  readonly pendingDeadline: Effect.Effect<Option.Option<number>, ThreadProjectionError>;
+}
+declare const ThreadProjectionMaintenance_base: Context.ServiceClass<ThreadProjectionMaintenance, "@effect-agent/thread/ThreadProjectionMaintenance", ThreadProjectionMaintenanceService>;
+declare class ThreadProjectionMaintenance extends ThreadProjectionMaintenance_base {
+  static readonly layer: Layer.Layer<ThreadProjectionMaintenance, never, never>;
+}
+/** Run at most one due backfill batch, preserving typed failures, defects and interruption. */
+declare const drainDue: Effect.Effect<boolean, ThreadProjectionError, ThreadProjectionMaintenance>;
+//#endregion
+export { ThreadProjectionError, ThreadProjectionMaintenance, ThreadProjectionMaintenanceService, drainDue, ThreadProjectionMaintenance_d_exports as t };
+//# sourceMappingURL=ThreadProjectionMaintenance.d.mts.map

package/dist/durable/ThreadProjectionMaintenance.mjs

@@ -0,0 +1,33 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { Clock, Context, Effect, Layer, Option, Schema } from "effect";
+//#region src/durable/ThreadProjectionMaintenance.ts
+var ThreadProjectionMaintenance_exports = /* @__PURE__ */ __exportAll({
+	ThreadProjectionError: () => ThreadProjectionError,
+	ThreadProjectionMaintenance: () => ThreadProjectionMaintenance,
+	drainDue: () => drainDue
+});
+/** A derived projection failed; the canonical source remains authoritative. */
+var ThreadProjectionError = class extends Schema.TaggedError()("ThreadProjectionError", {
+	operation: Schema.String,
+	message: Schema.String,
+	cause: Schema.optionalKey(Schema.Defect())
+}) {};
+var ThreadProjectionMaintenance = class extends Context.Service()("@effect-agent/thread/ThreadProjectionMaintenance") {
+	static layer = Layer.succeed(this)({
+		applyCommitted: () => Effect.void,
+		drain: Effect.void,
+		pendingDeadline: Effect.succeed(Option.none())
+	});
+};
+/** Run at most one due backfill batch, preserving typed failures, defects and interruption. */
+const drainDue = Effect.gen(function* () {
+	const projection = yield* ThreadProjectionMaintenance;
+	const deadline = yield* projection.pendingDeadline;
+	if (Option.isNone(deadline) || deadline.value > (yield* Clock.currentTimeMillis)) return false;
+	yield* projection.drain;
+	return true;
+});
+//#endregion
+export { ThreadProjectionError, ThreadProjectionMaintenance, drainDue, ThreadProjectionMaintenance_exports as t };
+
+//# sourceMappingURL=ThreadProjectionMaintenance.mjs.map

package/dist/durable/ThreadProjectionMaintenance.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadProjectionMaintenance.mjs","names":[],"sources":["../../src/durable/ThreadProjectionMaintenance.ts"],"sourcesContent":["import { Clock, Context, Effect, Layer, Option, Schema } from \"effect\";\n\nimport type { AppendResult, FencedAppendRequest } from \"./ThreadStore.ts\";\n\n/** A derived projection failed; the canonical source remains authoritative. */\nexport class ThreadProjectionError extends Schema.TaggedError<ThreadProjectionError>()(\n  \"ThreadProjectionError\",\n  {\n    operation: Schema.String,\n    message: Schema.String,\n    cause: Schema.optionalKey(Schema.Defect()),\n  },\n) {}\n\n/**\n * Host-owned, disposable indexes over a canonical Thread. Hooks receive raw local source\n * ports at construction and must not mutate them or acquire source producer ownership.\n * Rows and their contiguous watermark commit atomically; an empty projection still consumes\n * its record. Concurrent work must compare the starting watermark before committing.\n *\n * No method owns a scheduler. The platform owns wakeups, durable scheduling metadata and\n * source-producer fencing. Per-call resources belong to Scope; interruption remains interruption.\n */\nexport interface ThreadProjectionMaintenanceService {\n  /**\n   * Runs after a successful source commit and before dependent Tools can execute. An index\n   * caught up through firstSequence - 1 must process the entire committed range, including\n   * empty records, before returning. Canonical batches contain at most 256 records: chunk\n   * within local byte limits and stop at result.lastSequence, never chase a changing tail.\n   * An earlier gap defers to drain. Replayed or superseded ranges are idempotent no-ops.\n   * Failure must leave the unprocessed prefix visible to pendingDeadline.\n   */\n  readonly applyCommitted: (\n    request: FencedAppendRequest,\n    result: AppendResult,\n  ) => Effect.Effect<void, ThreadProjectionError>;\n  /** One bounded, restartable backfill batch. Never drain until caught up in a loop. */\n  readonly drain: Effect.Effect<void, ThreadProjectionError>;\n  /**\n   * Bounded local inspection. None means caught up; a pending epoch-millisecond deadline\n   * survives reconstruction and repeated reads must not postpone it. Projection backlog\n   * does not gate canonical execution or host approval publication.\n   */\n  readonly pendingDeadline: Effect.Effect<Option.Option<number>, ThreadProjectionError>;\n}\n\nexport class ThreadProjectionMaintenance extends Context.Service<\n  ThreadProjectionMaintenance,\n  ThreadProjectionMaintenanceService\n>()(\"@effect-agent/thread/ThreadProjectionMaintenance\") {\n  static readonly layer = Layer.succeed(this)({\n    applyCommitted: () => Effect.void,\n    drain: Effect.void,\n    pendingDeadline: Effect.succeed(Option.none()),\n  });\n}\n\n/** Run at most one due backfill batch, preserving typed failures, defects and interruption. */\nexport const drainDue = Effect.gen(function* () {\n  const projection = yield* ThreadProjectionMaintenance;\n  const deadline = yield* projection.pendingDeadline;\n\n  if (Option.isNone(deadline) || deadline.value > (yield* Clock.currentTimeMillis)) return false;\n  yield* projection.drain;\n\n  return true;\n});\n"],"mappings":";;;;;;;;;AAKA,IAAa,wBAAb,cAA2C,OAAO,YAAmC,CAAC,CACpF,yBACA;CACE,WAAW,OAAO;CAClB,SAAS,OAAO;CAChB,OAAO,OAAO,YAAY,OAAO,OAAO,CAAC;AAC3C,CACF,CAAC,CAAC,CAAC;AAkCH,IAAa,8BAAb,cAAiD,QAAQ,QAGvD,CAAC,CAAC,kDAAkD,CAAC,CAAC;CACtD,OAAgB,QAAQ,MAAM,QAAQ,IAAI,CAAC,CAAC;EAC1C,sBAAsB,OAAO;EAC7B,OAAO,OAAO;EACd,iBAAiB,OAAO,QAAQ,OAAO,KAAK,CAAC;CAC/C,CAAC;AACH;;AAGA,MAAa,WAAW,OAAO,IAAI,aAAa;CAC9C,MAAM,aAAa,OAAO;CAC1B,MAAM,WAAW,OAAO,WAAW;CAEnC,IAAI,OAAO,OAAO,QAAQ,KAAK,SAAS,SAAS,OAAO,MAAM,oBAAoB,OAAO;CACzF,OAAO,WAAW;CAElB,OAAO;AACT,CAAC"}

package/dist/durable/ThreadStore.d.mts

@@ -0,0 +1,2 @@
+import { $t as ThreadObservation, Bt as CheckpointRejected, Gt as SaveCheckpointRequest, Ht as FencedAppendRequest, Jt as ThreadCheckpoints, Kt as SaveRecoveryCheckpointRequest, Qt as ThreadNotMaterialized, Rt as AppendConflict, Ut as LoadCheckpointRequest, Vt as FenceRejected, Wt as MAX_THREAD_EXPORT_RECORDS, Xt as ThreadExportRequest, Yt as ThreadExport, Zt as ThreadMaterialization, en as ThreadRead, in as ThreadStoreFailure, nn as ThreadStore, on as ThreadTail, qt as ThreadCheckpoint, rn as ThreadStoreError, sn as ThreadTailRequest, tn as ThreadRecoveryCheckpoints, zt as AppendResult } from "../Records-BAGkekt8.mjs";
+export { AppendConflict, AppendResult, CheckpointRejected, FenceRejected, FencedAppendRequest, LoadCheckpointRequest, MAX_THREAD_EXPORT_RECORDS, SaveCheckpointRequest, SaveRecoveryCheckpointRequest, ThreadCheckpoint, ThreadCheckpoints, ThreadExport, ThreadExportRequest, ThreadMaterialization, ThreadNotMaterialized, ThreadObservation, ThreadRead, ThreadRecoveryCheckpoints, ThreadStore, ThreadStoreError, ThreadStoreFailure, ThreadTail, ThreadTailRequest };

package/dist/durable/ThreadStore.mjs

@@ -0,0 +1,147 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { ThreadId } from "../core/Identifiers.mjs";
+import { BatchId, CanonicalBatch, CanonicalRecordEnvelope, CanonicalSequence, Digest, ObservationOffset, PersistedJson, ProducerEpoch } from "./Records.mjs";
+import { Context, Schema } from "effect";
+//#region src/durable/ThreadStore.ts
+var ThreadStore_exports = /* @__PURE__ */ __exportAll({
+	AppendConflict: () => AppendConflict,
+	AppendResult: () => AppendResult,
+	CheckpointRejected: () => CheckpointRejected,
+	FenceRejected: () => FenceRejected,
+	FencedAppendRequest: () => FencedAppendRequest,
+	LoadCheckpointRequest: () => LoadCheckpointRequest,
+	MAX_THREAD_EXPORT_RECORDS: () => MAX_THREAD_EXPORT_RECORDS,
+	SaveCheckpointRequest: () => SaveCheckpointRequest,
+	SaveRecoveryCheckpointRequest: () => SaveRecoveryCheckpointRequest,
+	ThreadCheckpoint: () => ThreadCheckpoint,
+	ThreadExport: () => ThreadExport,
+	ThreadExportRequest: () => ThreadExportRequest,
+	ThreadMaterialization: () => ThreadMaterialization,
+	ThreadNotMaterialized: () => ThreadNotMaterialized,
+	ThreadObservation: () => ThreadObservation,
+	ThreadRead: () => ThreadRead,
+	ThreadStore: () => ThreadStore,
+	ThreadStoreError: () => ThreadStoreError,
+	ThreadTail: () => ThreadTail,
+	ThreadTailRequest: () => ThreadTailRequest
+});
+var ThreadMaterialization = class extends Schema.Class("@effect-agent/thread/ThreadMaterialization")({
+	threadId: ThreadId,
+	producerEpoch: ProducerEpoch
+}) {};
+var FencedAppendRequest = class extends Schema.Class("@effect-agent/thread/FencedAppendRequest")({
+	threadId: ThreadId,
+	batch: CanonicalBatch,
+	expectedTailSequence: CanonicalSequence,
+	expectedTailDigest: Digest,
+	producerEpoch: ProducerEpoch
+}) {};
+var AppendResult = class extends Schema.Class("@effect-agent/thread/AppendResult")({
+	firstSequence: CanonicalSequence,
+	lastSequence: CanonicalSequence,
+	tailDigest: Digest,
+	replayed: Schema.Boolean
+}) {};
+var ThreadRead = class extends Schema.Class("@effect-agent/thread/ThreadRead")({
+	threadId: ThreadId,
+	afterSequence: Schema.optionalKey(CanonicalSequence),
+	limit: Schema.Natural.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(1024))
+}) {};
+var ThreadObservation = class extends Schema.Class("@effect-agent/thread/ThreadObservation")({
+	threadId: ThreadId,
+	afterOffset: Schema.optionalKey(ObservationOffset)
+}) {};
+var ThreadExportRequest = class extends Schema.Class("@effect-agent/thread/ThreadExportRequest")({ threadId: ThreadId }) {};
+var ThreadTailRequest = class extends Schema.Class("@effect-agent/thread/ThreadTailRequest")({ threadId: ThreadId }) {};
+/**
+* The committed tail of one Thread Log. A resuming producer composes its next
+* FencedAppendRequest from this value instead of exporting the whole log.
+*/
+var ThreadTail = class extends Schema.Class("@effect-agent/thread/ThreadTail")({
+	threadId: ThreadId,
+	tailSequence: CanonicalSequence,
+	tailDigest: Digest,
+	producerEpoch: ProducerEpoch
+}) {};
+/** Maximum canonical records represented by one Thread export. */
+const MAX_THREAD_EXPORT_RECORDS = 131072;
+var ThreadExport = class extends Schema.Class("@effect-agent/thread/ThreadExport")({
+	format: Schema.Literal("effect-agent/thread@1"),
+	threadId: ThreadId,
+	tailSequence: CanonicalSequence,
+	tailDigest: Digest,
+	records: Schema.Array(CanonicalRecordEnvelope).check(Schema.isMaxLength(MAX_THREAD_EXPORT_RECORDS))
+}) {};
+/**
+* A disposable projection snapshot. Adapters bind its sequence and digest to the canonical
+* log; consumers decode `state` and decide projection compatibility before suffix replay.
+* Legacy metadata is optional for application projections and preserved when supplied.
+* Runtime-owned recovery checkpoints populate and compare it before using cached state.
+*/
+var ThreadCheckpoint = class extends Schema.Class("@effect-agent/thread/ThreadCheckpoint")({
+	schemaVersion: Schema.Literal(1),
+	threadId: ThreadId,
+	throughSequence: CanonicalSequence,
+	tailDigest: Digest,
+	/** @deprecated For application projections; retained for existing data and runtime recovery. */
+	engineVersion: Schema.optionalKey(Schema.NonEmptyString),
+	/** @deprecated For application projections; retained for existing data and runtime recovery. */
+	agentDefinitionDigest: Schema.optionalKey(Digest),
+	/** @deprecated For application projections; retained for existing data and runtime recovery. */
+	modelDigest: Schema.optionalKey(Digest),
+	/** @deprecated For application projections; retained for existing data and runtime recovery. */
+	toolDigest: Schema.optionalKey(Digest),
+	state: PersistedJson,
+	createdAt: Schema.DateTimeUtcFromString
+}) {};
+var SaveCheckpointRequest = class extends Schema.Class("@effect-agent/thread/SaveCheckpointRequest")({ checkpoint: ThreadCheckpoint }) {};
+/** Replace the disposable recovery view only under the current canonical producer fence. */
+var SaveRecoveryCheckpointRequest = class extends Schema.Class("@effect-agent/thread/SaveRecoveryCheckpointRequest")({
+	checkpoint: ThreadCheckpoint,
+	producerEpoch: ProducerEpoch
+}) {};
+var LoadCheckpointRequest = class extends Schema.Class("@effect-agent/thread/LoadCheckpointRequest")({
+	threadId: ThreadId,
+	atOrBeforeSequence: Schema.optionalKey(CanonicalSequence)
+}) {};
+var ThreadStoreError = class extends Schema.TaggedError()("ThreadStoreError", {
+	operation: Schema.String,
+	message: Schema.String,
+	cause: Schema.optionalKey(Schema.Defect())
+}) {};
+var ThreadNotMaterialized = class extends Schema.TaggedError()("ThreadNotMaterialized", { threadId: ThreadId }) {};
+/**
+* A canonical append that cannot commit: `batch-digest` replays a batch ID with different
+* content, `record-identity` reuses a canonical record ID, and `tail` declares a stale expected
+* tail. Tail conflicts carry the actual committed tail as a diagnostic resume hint.
+*/
+var AppendConflict = class extends Schema.TaggedError()("AppendConflict", {
+	threadId: ThreadId,
+	batchId: BatchId,
+	reason: Schema.Literals([
+		"batch-digest",
+		"record-identity",
+		"tail"
+	]),
+	actualTailSequence: Schema.optionalKey(CanonicalSequence),
+	actualTailDigest: Schema.optionalKey(Digest)
+}) {};
+var FenceRejected = class extends Schema.TaggedError()("FenceRejected", {
+	threadId: ThreadId,
+	actualEpoch: ProducerEpoch,
+	attemptedEpoch: ProducerEpoch
+}) {};
+var CheckpointRejected = class extends Schema.TaggedError()("CheckpointRejected", {
+	threadId: ThreadId,
+	reason: Schema.Literals([
+		"ahead-of-tail",
+		"digest-mismatch",
+		"unsupported-version",
+		"corrupt"
+	])
+}) {};
+var ThreadStore = class extends Context.Service()("@effect-agent/thread/ThreadStore") {};
+//#endregion
+export { AppendConflict, AppendResult, CheckpointRejected, FenceRejected, FencedAppendRequest, LoadCheckpointRequest, MAX_THREAD_EXPORT_RECORDS, SaveCheckpointRequest, SaveRecoveryCheckpointRequest, ThreadCheckpoint, ThreadExport, ThreadExportRequest, ThreadMaterialization, ThreadNotMaterialized, ThreadObservation, ThreadRead, ThreadStore, ThreadStoreError, ThreadTail, ThreadTailRequest, ThreadStore_exports as t };
+
+//# sourceMappingURL=ThreadStore.mjs.map

package/dist/durable/ThreadStore.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadStore.mjs","names":[],"sources":["../../src/durable/ThreadStore.ts"],"sourcesContent":["import type { Effect, Option, Stream } from \"effect\";\nimport { Context, Schema } from \"effect\";\n\nimport { ThreadId } from \"../core/Identifiers.ts\";\nimport {\n  BatchId,\n  CanonicalBatch,\n  CanonicalRecordEnvelope,\n  CanonicalSequence,\n  Digest,\n  ObservationOffset,\n  PersistedJson,\n  ProducerEpoch,\n} from \"./Records.ts\";\n\nexport class ThreadMaterialization extends Schema.Class<ThreadMaterialization>(\n  \"@effect-agent/thread/ThreadMaterialization\",\n)({\n  threadId: ThreadId,\n  producerEpoch: ProducerEpoch,\n}) {}\n\nexport class FencedAppendRequest extends Schema.Class<FencedAppendRequest>(\n  \"@effect-agent/thread/FencedAppendRequest\",\n)({\n  threadId: ThreadId,\n  batch: CanonicalBatch,\n  expectedTailSequence: CanonicalSequence,\n  expectedTailDigest: Digest,\n  producerEpoch: ProducerEpoch,\n}) {}\n\nexport class AppendResult extends Schema.Class<AppendResult>(\"@effect-agent/thread/AppendResult\")({\n  firstSequence: CanonicalSequence,\n  lastSequence: CanonicalSequence,\n  tailDigest: Digest,\n  replayed: Schema.Boolean,\n}) {}\n\nexport class ThreadRead extends Schema.Class<ThreadRead>(\"@effect-agent/thread/ThreadRead\")({\n  threadId: ThreadId,\n  afterSequence: Schema.optionalKey(CanonicalSequence),\n  limit: Schema.Natural.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(1_024)),\n}) {}\n\nexport class ThreadObservation extends Schema.Class<ThreadObservation>(\n  \"@effect-agent/thread/ThreadObservation\",\n)({\n  threadId: ThreadId,\n  afterOffset: Schema.optionalKey(ObservationOffset),\n}) {}\n\nexport class ThreadExportRequest extends Schema.Class<ThreadExportRequest>(\n  \"@effect-agent/thread/ThreadExportRequest\",\n)({\n  threadId: ThreadId,\n}) {}\n\nexport class ThreadTailRequest extends Schema.Class<ThreadTailRequest>(\n  \"@effect-agent/thread/ThreadTailRequest\",\n)({\n  threadId: ThreadId,\n}) {}\n\n/**\n * The committed tail of one Thread Log. A resuming producer composes its next\n * FencedAppendRequest from this value instead of exporting the whole log.\n */\nexport class ThreadTail extends Schema.Class<ThreadTail>(\"@effect-agent/thread/ThreadTail\")({\n  threadId: ThreadId,\n  tailSequence: CanonicalSequence,\n  tailDigest: Digest,\n  producerEpoch: ProducerEpoch,\n}) {}\n\n/** Maximum canonical records represented by one Thread export. */\nexport const MAX_THREAD_EXPORT_RECORDS = 131_072;\n\nexport class ThreadExport extends Schema.Class<ThreadExport>(\"@effect-agent/thread/ThreadExport\")({\n  format: Schema.Literal(\"effect-agent/thread@1\"),\n  threadId: ThreadId,\n  tailSequence: CanonicalSequence,\n  tailDigest: Digest,\n  records: Schema.Array(CanonicalRecordEnvelope).check(\n    Schema.isMaxLength(MAX_THREAD_EXPORT_RECORDS),\n  ),\n}) {}\n\n/**\n * A disposable projection snapshot. Adapters bind its sequence and digest to the canonical\n * log; consumers decode `state` and decide projection compatibility before suffix replay.\n * Legacy metadata is optional for application projections and preserved when supplied.\n * Runtime-owned recovery checkpoints populate and compare it before using cached state.\n */\nexport class ThreadCheckpoint extends Schema.Class<ThreadCheckpoint>(\n  \"@effect-agent/thread/ThreadCheckpoint\",\n)({\n  schemaVersion: Schema.Literal(1),\n  threadId: ThreadId,\n  throughSequence: CanonicalSequence,\n  tailDigest: Digest,\n  /** @deprecated For application projections; retained for existing data and runtime recovery. */\n  engineVersion: Schema.optionalKey(Schema.NonEmptyString),\n  /** @deprecated For application projections; retained for existing data and runtime recovery. */\n  agentDefinitionDigest: Schema.optionalKey(Digest),\n  /** @deprecated For application projections; retained for existing data and runtime recovery. */\n  modelDigest: Schema.optionalKey(Digest),\n  /** @deprecated For application projections; retained for existing data and runtime recovery. */\n  toolDigest: Schema.optionalKey(Digest),\n  state: PersistedJson,\n  createdAt: Schema.DateTimeUtcFromString,\n}) {}\n\nexport class SaveCheckpointRequest extends Schema.Class<SaveCheckpointRequest>(\n  \"@effect-agent/thread/SaveCheckpointRequest\",\n)({\n  checkpoint: ThreadCheckpoint,\n}) {}\n\n/** Replace the disposable recovery view only under the current canonical producer fence. */\nexport class SaveRecoveryCheckpointRequest extends Schema.Class<SaveRecoveryCheckpointRequest>(\n  \"@effect-agent/thread/SaveRecoveryCheckpointRequest\",\n)({\n  checkpoint: ThreadCheckpoint,\n  producerEpoch: ProducerEpoch,\n}) {}\n\nexport class LoadCheckpointRequest extends Schema.Class<LoadCheckpointRequest>(\n  \"@effect-agent/thread/LoadCheckpointRequest\",\n)({\n  threadId: ThreadId,\n  atOrBeforeSequence: Schema.optionalKey(CanonicalSequence),\n}) {}\n\nexport class ThreadStoreError extends Schema.TaggedError<ThreadStoreError>()(\"ThreadStoreError\", {\n  operation: Schema.String,\n  message: Schema.String,\n  cause: Schema.optionalKey(Schema.Defect()),\n}) {}\n\nexport class ThreadNotMaterialized extends Schema.TaggedError<ThreadNotMaterialized>()(\n  \"ThreadNotMaterialized\",\n  { threadId: ThreadId },\n) {}\n\n/**\n * A canonical append that cannot commit: `batch-digest` replays a batch ID with different\n * content, `record-identity` reuses a canonical record ID, and `tail` declares a stale expected\n * tail. Tail conflicts carry the actual committed tail as a diagnostic resume hint.\n */\nexport class AppendConflict extends Schema.TaggedError<AppendConflict>()(\"AppendConflict\", {\n  threadId: ThreadId,\n  batchId: BatchId,\n  reason: Schema.Literals([\"batch-digest\", \"record-identity\", \"tail\"]),\n  actualTailSequence: Schema.optionalKey(CanonicalSequence),\n  actualTailDigest: Schema.optionalKey(Digest),\n}) {}\n\nexport class FenceRejected extends Schema.TaggedError<FenceRejected>()(\"FenceRejected\", {\n  threadId: ThreadId,\n  actualEpoch: ProducerEpoch,\n  attemptedEpoch: ProducerEpoch,\n}) {}\n\nexport class CheckpointRejected extends Schema.TaggedError<CheckpointRejected>()(\n  \"CheckpointRejected\",\n  {\n    threadId: ThreadId,\n    reason: Schema.Literals([\"ahead-of-tail\", \"digest-mismatch\", \"unsupported-version\", \"corrupt\"]),\n  },\n) {}\n\nexport type ThreadStoreFailure =\n  | ThreadStoreError\n  | ThreadNotMaterialized\n  | AppendConflict\n  | FenceRejected;\n\n/**\n * Optional, disposable projection storage. Neither history execution nor durable recovery\n * requires it. Adapters that offer it must bind every checkpoint to a canonical batch tail.\n * Application consumers own projection compatibility; this port does not interpret metadata.\n */\nexport interface ThreadCheckpoints {\n  readonly save: (\n    request: SaveCheckpointRequest,\n  ) => Effect.Effect<void, ThreadStoreError | ThreadNotMaterialized | CheckpointRejected>;\n  readonly load: (\n    request: LoadCheckpointRequest,\n  ) => Effect.Effect<\n    Option.Option<ThreadCheckpoint>,\n    ThreadStoreError | ThreadNotMaterialized | CheckpointRejected\n  >;\n}\n\n/**\n * Optional latest-only recovery cache, independent of application projection checkpoints.\n * Saves atomically validate the producer epoch and canonical batch tail. An older snapshot\n * cannot replace a newer one; equal-tail replacement repairs disposable state. Invalid cached\n * data fails with CheckpointRejected, while infrastructure failures remain ThreadStoreError.\n * Loading at an earlier tail or outside the adapter's cache locality may return none so callers\n * can replay canonical records. Canonical records and the ledger remain authority.\n */\nexport interface ThreadRecoveryCheckpoints {\n  readonly save: (\n    request: SaveRecoveryCheckpointRequest,\n  ) => Effect.Effect<\n    void,\n    ThreadStoreError | ThreadNotMaterialized | CheckpointRejected | FenceRejected\n  >;\n  readonly load: ThreadCheckpoints[\"load\"];\n}\n\nexport class ThreadStore extends Context.Service<\n  ThreadStore,\n  {\n    readonly materialize: (\n      request: ThreadMaterialization,\n    ) => Effect.Effect<void, ThreadStoreError | FenceRejected>;\n    readonly append: (\n      request: FencedAppendRequest,\n    ) => Effect.Effect<\n      AppendResult,\n      ThreadStoreError | ThreadNotMaterialized | AppendConflict | FenceRejected\n    >;\n    readonly read: (\n      request: ThreadRead,\n    ) => Stream.Stream<CanonicalRecordEnvelope, ThreadStoreError | ThreadNotMaterialized>;\n    readonly observe: (\n      request: ThreadObservation,\n    ) => Stream.Stream<CanonicalRecordEnvelope, ThreadStoreError | ThreadNotMaterialized>;\n    readonly export: (\n      request: ThreadExportRequest,\n    ) => Effect.Effect<ThreadExport, ThreadStoreError | ThreadNotMaterialized>;\n    readonly inspectTail: (\n      request: ThreadTailRequest,\n    ) => Effect.Effect<ThreadTail, ThreadStoreError | ThreadNotMaterialized>;\n    /** Absent when this adapter does not support disposable checkpoints. */\n    readonly checkpoints?: ThreadCheckpoints | undefined;\n    readonly recoveryCheckpoints?: ThreadRecoveryCheckpoints | undefined;\n  }\n>()(\"@effect-agent/thread/ThreadStore\") {}\n"],"mappings":"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"}

package/dist/durable/ThreadStoreConformance.d.mts

@@ -0,0 +1,29 @@
+import { Bt as CheckpointRejected, in as ThreadStoreFailure, nn as ThreadStore } from "../Records-BAGkekt8.mjs";
+import { Effect, Schema } from "effect";
+//#region src/durable/ThreadStoreConformance.d.ts
+declare const ThreadStoreConformanceViolation_base: Schema.Class<ThreadStoreConformanceViolation, Schema.TaggedStruct<"ThreadStoreConformanceViolation", {
+  readonly caseName: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A ThreadStore contract invariant that an adapter under test violated. */
+declare class ThreadStoreConformanceViolation extends ThreadStoreConformanceViolation_base {}
+type ThreadStoreConformanceFailure = ThreadStoreFailure | CheckpointRejected | ThreadStoreConformanceViolation;
+/**
+ * One adapter-neutral ThreadStore contract case. Each case owns disjoint
+ * Thread identities, so a suite may run every case against one shared store
+ * instance or against a fresh store per case.
+ */
+interface ThreadStoreConformanceCase {
+  readonly name: string;
+  readonly run: Effect.Effect<void, ThreadStoreConformanceFailure, ThreadStore>;
+}
+/**
+ * The shared, adapter-parameterized ThreadStore contract suite (STORE-010). Every
+ * durable adapter test suite must execute each case against its own store provisioning.
+ */
+declare const threadStoreConformanceCases: ReadonlyArray<ThreadStoreConformanceCase>;
+/** Additional contract cases only for adapters advertising `ThreadStore.checkpoints`. */
+declare const threadCheckpointConformanceCases: ReadonlyArray<ThreadStoreConformanceCase>;
+//#endregion
+export { ThreadStoreConformanceCase, ThreadStoreConformanceFailure, ThreadStoreConformanceViolation, threadCheckpointConformanceCases, threadStoreConformanceCases };
+//# sourceMappingURL=ThreadStoreConformance.d.mts.map

package/dist/durable/ThreadStoreConformance.mjs

@@ -0,0 +1,248 @@
+import { RunId, SubmissionId, ThreadId } from "../core/Identifiers.mjs";
+import { BatchId, CanonicalBatch, CanonicalSequence, DeploymentId, ProducerEpoch, ProducerId, RecordEnvelope, RecordId, UserInputRecorded } from "./Records.mjs";
+import { EMPTY_TAIL_DIGEST } from "./Digest.mjs";
+import { AppendConflict, CheckpointRejected, FenceRejected, FencedAppendRequest, LoadCheckpointRequest, SaveCheckpointRequest, ThreadCheckpoint, ThreadExportRequest, ThreadMaterialization, ThreadNotMaterialized, ThreadObservation, ThreadRead, ThreadStore, ThreadTailRequest } from "./ThreadStore.mjs";
+import { DateTime, Effect, Option, Schema, Stream } from "effect";
+//#region src/durable/ThreadStoreConformance.ts
+/** A ThreadStore contract invariant that an adapter under test violated. */
+var ThreadStoreConformanceViolation = class extends Schema.TaggedError()("ThreadStoreConformanceViolation", {
+	caseName: Schema.String,
+	message: Schema.String
+}) {};
+const decodeThreadId = Schema.decodeSync(ThreadId);
+const decodeRecordId = Schema.decodeSync(RecordId);
+const decodeBatchId = Schema.decodeSync(BatchId);
+const decodeSequence = Schema.decodeSync(CanonicalSequence);
+const decodeEpoch = Schema.decodeSync(ProducerEpoch);
+const CONFORMANCE_DEPLOYMENT = Schema.decodeSync(DeploymentId)("deployment-conformance");
+const CONFORMANCE_PRODUCER = Schema.decodeSync(ProducerId)("producer-conformance");
+const CONFORMANCE_SUBMISSION = Schema.decodeSync(SubmissionId)("submission-conformance");
+const CONFORMANCE_RUN = Schema.decodeSync(RunId)("run-conformance");
+const CONFORMANCE_CREATED_AT = DateTime.toUtc(DateTime.makeUnsafe(1));
+const ZERO_SEQUENCE = decodeSequence(0);
+const EPOCH_ONE = decodeEpoch(1);
+const EPOCH_TWO = decodeEpoch(2);
+const EMPTY_TAIL = {
+	lastSequence: ZERO_SEQUENCE,
+	tailDigest: EMPTY_TAIL_DIGEST
+};
+const isAppendConflict = Schema.is(AppendConflict);
+const isFenceRejected = Schema.is(FenceRejected);
+const isCheckpointRejected = Schema.is(CheckpointRejected);
+const isThreadNotMaterialized = Schema.is(ThreadNotMaterialized);
+const record = (recordId, input) => RecordEnvelope.make({
+	recordId: decodeRecordId(recordId),
+	family: "thread",
+	schemaVersion: 1,
+	createdAt: CONFORMANCE_CREATED_AT,
+	deploymentId: CONFORMANCE_DEPLOYMENT,
+	payload: UserInputRecorded.make({
+		submissionId: CONFORMANCE_SUBMISSION,
+		kind: "user",
+		runId: CONFORMANCE_RUN,
+		input
+	})
+});
+const batch = (batchId, records) => CanonicalBatch.make({
+	batchId: decodeBatchId(batchId),
+	producerId: CONFORMANCE_PRODUCER,
+	records
+});
+const materialize = Effect.fn("ThreadStoreConformance.materialize")(function* (threadId, producerEpoch) {
+	yield* (yield* ThreadStore).materialize(ThreadMaterialization.make({
+		threadId,
+		producerEpoch
+	}));
+});
+const append = Effect.fn("ThreadStoreConformance.append")(function* (threadId, canonicalBatch, tail = EMPTY_TAIL, producerEpoch = EPOCH_ONE) {
+	return yield* (yield* ThreadStore).append(FencedAppendRequest.make({
+		threadId,
+		batch: canonicalBatch,
+		expectedTailSequence: tail.lastSequence,
+		expectedTailDigest: tail.tailDigest,
+		producerEpoch
+	}));
+});
+const readAll = Effect.fn("ThreadStoreConformance.readAll")(function* (threadId) {
+	return yield* (yield* ThreadStore).read(ThreadRead.make({
+		threadId,
+		limit: 1024
+	})).pipe(Stream.runCollect);
+});
+const checkpointAt = (threadId, throughSequence, tailDigest) => ThreadCheckpoint.make({
+	schemaVersion: 1,
+	threadId,
+	throughSequence,
+	tailDigest,
+	state: { conformance: true },
+	createdAt: CONFORMANCE_CREATED_AT
+});
+const conformanceCase = (name, build) => ({
+	name,
+	run: build({
+		ensure: (condition, message) => condition ? Effect.void : Effect.fail(ThreadStoreConformanceViolation.make({
+			caseName: name,
+			message
+		})),
+		expectFailure: (description, effect) => Effect.flip(effect).pipe(Effect.mapError(() => ThreadStoreConformanceViolation.make({
+			caseName: name,
+			message: `Expected failure but the operation succeeded: ${description}`
+		})))
+	}).pipe(Effect.withSpan(`ThreadStoreConformance.${name}`))
+});
+const atomicBatchVisibility = conformanceCase("commits batches atomically with no partial reader visibility", ({ ensure, expectFailure }) => Effect.gen(function* () {
+	const threadId = decodeThreadId("conformance-atomic");
+	const store = yield* ThreadStore;
+	yield* materialize(threadId, EPOCH_ONE);
+	const committed = yield* append(threadId, batch("atomic-batch-1", [
+		record("atomic-record-1", "first"),
+		record("atomic-record-2", "second"),
+		record("atomic-record-3", "third")
+	]));
+	yield* ensure(committed.firstSequence === 1 && committed.lastSequence === 3, "A three-record batch must commit sequences 1 through 3");
+	const read = yield* readAll(threadId);
+	yield* ensure(read.length === 3, "Readers must observe the full committed batch");
+	yield* ensure(read.every((envelope, index) => envelope.sequence === index + 1), "Committed records must be gap-free in declaration order");
+	yield* ensure((yield* store.observe(ThreadObservation.make({ threadId })).pipe(Stream.take(3), Stream.runCollect)).map((envelope) => envelope.record.recordId).join(",") === read.map((envelope) => envelope.record.recordId).join(","), "Observers must see exactly the committed batch records in order");
+	const duplicate = record("atomic-record-4", "duplicate");
+	const intraBatch = yield* expectFailure("a batch containing one record ID twice", append(threadId, batch("atomic-batch-2", [duplicate, duplicate]), committed));
+	yield* ensure(isAppendConflict(intraBatch) && intraBatch.reason === "record-identity", "A duplicated record ID inside one batch must conflict with reason record-identity");
+	const crossBatch = yield* expectFailure("a batch reusing an already-committed record ID", append(threadId, batch("atomic-batch-3", [record("atomic-record-1", "reused")]), committed));
+	yield* ensure(isAppendConflict(crossBatch) && crossBatch.reason === "record-identity", "A record ID reused across batches must conflict with reason record-identity");
+	const exported = yield* store.export(ThreadExportRequest.make({ threadId }));
+	yield* ensure(exported.records.length === 3 && exported.tailSequence === committed.lastSequence && exported.tailDigest === committed.tailDigest, "A conflicting batch must leave no partial prefix behind");
+}));
+const idempotentReplay = conformanceCase("replays an identical batch idempotently and rejects altered content", ({ ensure, expectFailure }) => Effect.gen(function* () {
+	const threadId = decodeThreadId("conformance-replay");
+	yield* materialize(threadId, EPOCH_ONE);
+	const original = batch("replay-batch-1", [record("replay-record-1", "Lisbon"), record("replay-record-2", "Porto")]);
+	const first = yield* append(threadId, original);
+	yield* ensure(!first.replayed, "The first append of a batch must not report replayed");
+	const replayed = yield* append(threadId, original);
+	yield* ensure(replayed.replayed && replayed.firstSequence === first.firstSequence && replayed.lastSequence === first.lastSequence && replayed.tailDigest === first.tailDigest, "Replaying an identical batch must return the original result with replayed set");
+	const altered = yield* expectFailure("replaying a batch ID with different canonical content", append(threadId, batch("replay-batch-1", [record("replay-record-3", "Faro")])));
+	yield* ensure(isAppendConflict(altered) && altered.reason === "batch-digest", "A batch ID replayed with different content must conflict with reason batch-digest");
+	yield* ensure((yield* readAll(threadId)).length === 2, "Replay and conflict must not duplicate committed records");
+}));
+const tailConflict = conformanceCase("rejects stale expected tails and reports the actual tail", ({ ensure, expectFailure }) => Effect.gen(function* () {
+	const threadId = decodeThreadId("conformance-tail");
+	yield* materialize(threadId, EPOCH_ONE);
+	const first = yield* append(threadId, batch("tail-batch-1", [record("tail-record-1", "first")]));
+	const staleSequence = yield* expectFailure("an append declaring the pre-append tail sequence", append(threadId, batch("tail-batch-2", [record("tail-record-2", "second")])));
+	yield* ensure(isAppendConflict(staleSequence) && staleSequence.reason === "tail", "A stale expected tail sequence must conflict with reason tail");
+	yield* ensure(isAppendConflict(staleSequence) && staleSequence.actualTailSequence === first.lastSequence && staleSequence.actualTailDigest === first.tailDigest, "A tail conflict must carry the actual committed tail as a resume hint");
+	const staleDigest = yield* expectFailure("an append declaring the right sequence with the wrong digest", append(threadId, batch("tail-batch-2", [record("tail-record-2", "second")]), {
+		lastSequence: first.lastSequence,
+		tailDigest: EMPTY_TAIL_DIGEST
+	}));
+	yield* ensure(isAppendConflict(staleDigest) && staleDigest.reason === "tail", "A stale expected tail digest must conflict with reason tail");
+	yield* ensure((yield* append(threadId, batch("tail-batch-2", [record("tail-record-2", "second")]), first)).firstSequence === first.lastSequence + 1, "An append declaring the true tail must commit after a tail conflict");
+}));
+const producerFencing = conformanceCase("fences stale producer epochs while allowing epoch takeover", ({ ensure, expectFailure }) => Effect.gen(function* () {
+	const threadId = decodeThreadId("conformance-fencing");
+	yield* materialize(threadId, EPOCH_ONE);
+	const first = yield* append(threadId, batch("fence-batch-1", [record("fence-record-1", "first")]));
+	yield* materialize(threadId, EPOCH_TWO);
+	const staleAppend = yield* expectFailure("an append using the pre-takeover producer epoch", append(threadId, batch("fence-batch-2", [record("fence-record-2", "second")]), first, EPOCH_ONE));
+	yield* ensure(isFenceRejected(staleAppend) && staleAppend.actualEpoch === EPOCH_TWO && staleAppend.attemptedEpoch === EPOCH_ONE, "A stale producer epoch must be fenced with both epochs reported");
+	const staleMaterialize = yield* expectFailure("re-materializing with the pre-takeover producer epoch", materialize(threadId, EPOCH_ONE));
+	yield* ensure(isFenceRejected(staleMaterialize), "A stale producer epoch must not re-register through materialization");
+	const takeover = yield* append(threadId, batch("fence-batch-2", [record("fence-record-2", "second")]), first, EPOCH_TWO);
+	yield* ensure(!takeover.replayed && takeover.firstSequence === first.lastSequence + 1, "The takeover epoch must append after the committed tail");
+}));
+const offsetResumability = conformanceCase("resumes observation from a saved offset with exactly the suffix", ({ ensure }) => Effect.gen(function* () {
+	const threadId = decodeThreadId("conformance-offsets");
+	const store = yield* ThreadStore;
+	yield* materialize(threadId, EPOCH_ONE);
+	const first = yield* append(threadId, batch("offset-batch-1", [record("offset-record-1", "first"), record("offset-record-2", "second")]));
+	const second = yield* append(threadId, batch("offset-batch-2", [record("offset-record-3", "third")]), first);
+	yield* append(threadId, batch("offset-batch-3", [record("offset-record-4", "fourth")]), second);
+	const committed = yield* readAll(threadId);
+	yield* ensure(committed.length === 4, "All committed records must be readable");
+	const savedOffset = committed[1]?.offset;
+	yield* ensure(savedOffset !== void 0, "Committed records must carry observation offsets");
+	if (savedOffset === void 0) return;
+	yield* ensure((yield* store.observe(ThreadObservation.make({
+		threadId,
+		afterOffset: savedOffset
+	})).pipe(Stream.take(2), Stream.runCollect)).map((envelope) => envelope.record.recordId).join(",") === committed.slice(2).map((envelope) => envelope.record.recordId).join(","), "Observation from a saved offset must deliver exactly the suffix in order");
+	yield* ensure((yield* store.observe(ThreadObservation.make({ threadId })).pipe(Stream.take(4), Stream.runCollect)).map((envelope) => envelope.record.recordId).join(",") === committed.map((envelope) => envelope.record.recordId).join(","), "Observation without an offset must deliver the full log in order");
+}));
+const checkpointBoundaries = conformanceCase("enforces checkpoint save and load boundary rules", ({ ensure, expectFailure }) => Effect.gen(function* () {
+	const threadId = decodeThreadId("conformance-checkpoints");
+	const checkpoints = (yield* ThreadStore).checkpoints;
+	if (checkpoints === void 0) return yield* ThreadStoreConformanceViolation.make({
+		caseName: "enforces checkpoint save and load boundary rules",
+		message: "The optional checkpoint suite requires checkpoint support"
+	});
+	yield* ensure([yield* expectFailure("saving a checkpoint for an unmaterialized Thread", checkpoints.save(SaveCheckpointRequest.make({ checkpoint: checkpointAt(threadId, ZERO_SEQUENCE, EMPTY_TAIL_DIGEST) }))), yield* expectFailure("loading a checkpoint for an unmaterialized Thread", checkpoints.load(LoadCheckpointRequest.make({ threadId })))].every(isThreadNotMaterialized), "Checkpoints require a materialized Thread");
+	yield* materialize(threadId, EPOCH_ONE);
+	const first = yield* append(threadId, batch("checkpoint-batch-1", [record("checkpoint-record-1", "Kyoto")]));
+	const aheadOfTail = yield* expectFailure("a checkpoint claiming a sequence beyond the committed tail", checkpoints.save(SaveCheckpointRequest.make({ checkpoint: checkpointAt(threadId, decodeSequence(first.lastSequence + 1), first.tailDigest) })));
+	yield* ensure(isCheckpointRejected(aheadOfTail) && aheadOfTail.reason === "ahead-of-tail", "A checkpoint ahead of the tail must be rejected with reason ahead-of-tail");
+	const digestMismatch = yield* expectFailure("a checkpoint whose digest does not match the canonical chain", checkpoints.save(SaveCheckpointRequest.make({ checkpoint: checkpointAt(threadId, first.lastSequence, EMPTY_TAIL_DIGEST) })));
+	yield* ensure(isCheckpointRejected(digestMismatch) && digestMismatch.reason === "digest-mismatch", "A checkpoint with a mismatched digest must be rejected with reason digest-mismatch");
+	yield* ensure(Option.isNone(yield* checkpoints.load(LoadCheckpointRequest.make({ threadId }))), "Rejected checkpoints must not become loadable");
+	const valid = checkpointAt(threadId, first.lastSequence, first.tailDigest);
+	yield* checkpoints.save(SaveCheckpointRequest.make({ checkpoint: valid }));
+	yield* checkpoints.save(SaveCheckpointRequest.make({ checkpoint: valid }));
+	const loaded = yield* checkpoints.load(LoadCheckpointRequest.make({ threadId }));
+	yield* ensure(Option.isSome(loaded) && loaded.value.throughSequence === first.lastSequence && loaded.value.tailDigest === first.tailDigest, "A valid checkpoint must load bound to its canonical sequence and digest");
+	const beforeCheckpoint = yield* checkpoints.load(LoadCheckpointRequest.make({
+		threadId,
+		atOrBeforeSequence: ZERO_SEQUENCE
+	}));
+	yield* ensure(Option.isNone(beforeCheckpoint), "Checkpoint lookup must respect the atOrBeforeSequence bound");
+	yield* append(threadId, batch("checkpoint-batch-2", [record("checkpoint-record-2", "Nara")]), first);
+	const afterAppend = yield* checkpoints.load(LoadCheckpointRequest.make({ threadId }));
+	yield* ensure(Option.isSome(afterAppend) && afterAppend.value.throughSequence === first.lastSequence, "An older checkpoint must remain loadable after later appends");
+}));
+/**
+* The shared, adapter-parameterized ThreadStore contract suite (STORE-010). Every
+* durable adapter test suite must execute each case against its own store provisioning.
+*/
+const threadStoreConformanceCases = [
+	atomicBatchVisibility,
+	idempotentReplay,
+	tailConflict,
+	producerFencing,
+	offsetResumability,
+	conformanceCase("inspects the canonical tail so a resuming producer can compose its next append", ({ ensure, expectFailure }) => Effect.gen(function* () {
+		const threadId = decodeThreadId("conformance-tail-inspection");
+		const store = yield* ThreadStore;
+		const missing = yield* expectFailure("inspecting the tail of an unmaterialized Thread", store.inspectTail(ThreadTailRequest.make({ threadId })));
+		yield* ensure(isThreadNotMaterialized(missing) && missing.threadId === threadId, "Tail inspection of an unmaterialized Thread must fail as not materialized");
+		yield* materialize(threadId, EPOCH_ONE);
+		const empty = yield* store.inspectTail(ThreadTailRequest.make({ threadId }));
+		yield* ensure(empty.tailSequence === ZERO_SEQUENCE && empty.tailDigest === EMPTY_TAIL_DIGEST && empty.producerEpoch === EPOCH_ONE, "An empty Thread must report the zero tail and its registered epoch");
+		const first = yield* append(threadId, batch("inspect-batch-1", [record("inspect-record-1", "first")]));
+		const afterAppend = yield* store.inspectTail(ThreadTailRequest.make({ threadId }));
+		yield* ensure(afterAppend.tailSequence === first.lastSequence && afterAppend.tailDigest === first.tailDigest, "Tail inspection must match the latest AppendResult");
+		const resumed = yield* append(threadId, batch("inspect-batch-2", [record("inspect-record-2", "second")]), {
+			lastSequence: afterAppend.tailSequence,
+			tailDigest: afterAppend.tailDigest
+		}, afterAppend.producerEpoch);
+		yield* ensure(resumed.firstSequence === afterAppend.tailSequence + 1, "An append composed from the inspected tail must commit without exporting the log");
+		yield* materialize(threadId, EPOCH_TWO);
+		const afterTakeover = yield* store.inspectTail(ThreadTailRequest.make({ threadId }));
+		yield* ensure(afterTakeover.producerEpoch === EPOCH_TWO && afterTakeover.tailSequence === resumed.lastSequence, "Tail inspection must reflect epoch takeover without disturbing the tail");
+	})),
+	conformanceCase("fails every read and write against an unmaterialized Thread", ({ ensure, expectFailure }) => Effect.gen(function* () {
+		const threadId = decodeThreadId("conformance-not-materialized");
+		const store = yield* ThreadStore;
+		const failures = [
+			yield* expectFailure("appending to an unmaterialized Thread", append(threadId, batch("missing-batch-1", [record("missing-record-1", "first")]))),
+			yield* expectFailure("reading an unmaterialized Thread", readAll(threadId)),
+			yield* expectFailure("observing an unmaterialized Thread", store.observe(ThreadObservation.make({ threadId })).pipe(Stream.take(1), Stream.runCollect)),
+			yield* expectFailure("exporting an unmaterialized Thread", store.export(ThreadExportRequest.make({ threadId }))),
+			yield* expectFailure("inspecting the tail of an unmaterialized Thread", store.inspectTail(ThreadTailRequest.make({ threadId })))
+		];
+		yield* Effect.forEach(failures, (failure) => ensure(isThreadNotMaterialized(failure) && failure.threadId === threadId, "Operations against an unmaterialized Thread must fail as not materialized"), { discard: true });
+	}))
+];
+/** Additional contract cases only for adapters advertising `ThreadStore.checkpoints`. */
+const threadCheckpointConformanceCases = [checkpointBoundaries];
+//#endregion
+export { ThreadStoreConformanceViolation, threadCheckpointConformanceCases, threadStoreConformanceCases };
+
+//# sourceMappingURL=ThreadStoreConformance.mjs.map