@effect-agent/storage-cloudflare 0.1.0-beta.9 → 0.1.0-beta.90

package/dist/PortProtocol.mjs

@@ -0,0 +1,176 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Schema } from "effect";
+import { CanonicalRecordEnvelope } from "effect-agent/records";
+import { AppendConflict, AppendResult, FenceRejected, FencedAppendRequest, ThreadExport, ThreadExportRequest, ThreadMaterialization, ThreadNotMaterialized, ThreadRead, ThreadStoreError, ThreadTail, ThreadTailRequest } from "effect-agent/thread-store";
+import { AbortCommand, AbortIntent, AdmissionConflict, AdmissionPolicyError, AdmissionRequest, AdmissionResolution, AdmissionResult, ChildSettledNotification, ChildSettledOutcome, JoinedToHost, LedgerError, MarkReadyRequest, SettlementConflict, SubmissionLookup, SubmissionLookupByKey, SubmissionSnapshot } from "effect-agent/submission-ledger";
+//#region src/PortProtocol.ts
+var PortProtocol_exports = /* @__PURE__ */ __exportAll({
+	LedgerAdmitCall: () => LedgerAdmitCall,
+	LedgerAdmitResult: () => LedgerAdmitResult,
+	LedgerLookupCall: () => LedgerLookupCall,
+	LedgerLookupResult: () => LedgerLookupResult,
+	LedgerMarkReadyCall: () => LedgerMarkReadyCall,
+	LedgerMarkReadyResult: () => LedgerMarkReadyResult,
+	LedgerRecordChildSettledCall: () => LedgerRecordChildSettledCall,
+	LedgerRecordChildSettledResult: () => LedgerRecordChildSettledResult,
+	LedgerRequestAbortCall: () => LedgerRequestAbortCall,
+	LedgerRequestAbortResult: () => LedgerRequestAbortResult,
+	LedgerResolveAdmissionCall: () => LedgerResolveAdmissionCall,
+	LedgerResolveAdmissionResult: () => LedgerResolveAdmissionResult,
+	MAX_PORT_DIAGNOSTIC_LENGTH: () => MAX_PORT_DIAGNOSTIC_LENGTH,
+	PortFailed: () => PortFailed,
+	PortFailure: () => PortFailure,
+	PortProtocolError: () => PortProtocolError,
+	PortRequest: () => PortRequest,
+	PortResponse: () => PortResponse,
+	PortResult: () => PortResult,
+	PortSucceeded: () => PortSucceeded,
+	StoreAppendCall: () => StoreAppendCall,
+	StoreAppendResult: () => StoreAppendResult,
+	StoreExportCall: () => StoreExportCall,
+	StoreExportResult: () => StoreExportResult,
+	StoreInspectTailCall: () => StoreInspectTailCall,
+	StoreInspectTailResult: () => StoreInspectTailResult,
+	StoreMaterializeCall: () => StoreMaterializeCall,
+	StoreMaterializeResult: () => StoreMaterializeResult,
+	StoreReadPageCall: () => StoreReadPageCall,
+	StoreReadPageResult: () => StoreReadPageResult,
+	boundPortDiagnostic: () => boundPortDiagnostic,
+	decodePortRequest: () => decodePortRequest,
+	decodePortResponse: () => decodePortResponse,
+	encodePortRequest: () => encodePortRequest,
+	encodePortResponse: () => encodePortResponse
+});
+/**
+* The cross-Durable-Object port protocol (plan §1.3, D-P6-3): Schema request/response/error
+* envelopes for the CLOSED route-capable subset of the thread ports. One Thread's
+* Durable Object executes another Thread's request against its OWN local facets; the
+* envelopes here are the only values that cross the Object boundary, and they are
+* transport-agnostic — native Durable Object JS RPC is the shipped carrier, fetch-with-JSON
+* the documented fallback, and both move the same Schema-encoded JSON.
+*
+* The closed subset is exactly the set of operations the durable coordinator performs against
+* a FOREIGN Thread (parent/child establishment, status checks, abort propagation,
+* child-settlement notification, and the child-thread store operations used by
+* establishment, `verifySettledChild`, and result projection):
+*
+* - ledger: `admit`, `markReady`, `lookup`, `resolveAdmission`, `requestAbort`,
+*   `recordChildSettled`;
+* - store: `materialize`, `append`, `read` (one page), `inspectTail`, `export`.
+*
+* Every other port operation is lane-local and has no envelope. A foreign disposable
+* recovery-cache load returns a miss so the caller can replay canonical history. Other
+* foreign operations fail fast and typed instead of widening the distributed surface.
+*
+* Failures cross the boundary as the `PortFailure` union and re-decode on the caller side to
+* the SAME tagged error types the local facet would have produced, so routed calls keep
+* error-tag fidelity. `cause` chains inside `LedgerError`/`ThreadStoreError` travel as
+* Schema defects and do not claim instance fidelity across Objects (plan §2.8).
+*/
+/** Ceiling for protocol diagnostic strings; matches `AdmissionIndeterminate.reason`. */
+const MAX_PORT_DIAGNOSTIC_LENGTH = 4096;
+const BoundedDiagnostic = Schema.String.check(Schema.isMaxLength(MAX_PORT_DIAGNOSTIC_LENGTH));
+/** Truncate a diagnostic string to the protocol's bounded diagnostic length. */
+const boundPortDiagnostic = (value) => value.length > 4096 ? `${value.slice(0, 4093)}...` : value;
+/**
+* The envelope itself could not be honored: the receiving Object could not decode the
+* request, or a response could not be encoded/decoded. It never carries port semantics —
+* callers fold it into the operation's base error (`LedgerError`/`ThreadStoreError`),
+* except `resolveAdmission`, which folds it into `AdmissionIndeterminate` because a
+* non-answer is never proof of absence (SUB-031).
+*/
+var PortProtocolError = class extends Schema.TaggedError()("PortProtocolError", { message: BoundedDiagnostic }) {};
+/** Routed `SubmissionLedger.admit` — child establishment admits INTO the owning Object. */
+var LedgerAdmitCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerAdmitCall")("LedgerAdmit", { request: AdmissionRequest }) {};
+/** Routed `SubmissionLedger.markReady` for a Submission owned by another Object. */
+var LedgerMarkReadyCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerMarkReadyCall")("LedgerMarkReady", { request: MarkReadyRequest }) {};
+/** Routed `SubmissionLedger.lookup` (by identity or scoped idempotency key). */
+var LedgerLookupCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerLookupCall")("LedgerLookup", { request: SubmissionLookup }) {};
+/** Routed `SubmissionLedger.resolveAdmission` — the SUB-031 tri-state authority call. */
+var LedgerResolveAdmissionCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerResolveAdmissionCall")("LedgerResolveAdmission", { request: SubmissionLookupByKey }) {};
+/** Routed `SubmissionLedger.requestAbort` — abort propagation across Objects. */
+var LedgerRequestAbortCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerRequestAbortCall")("LedgerRequestAbort", { request: AbortCommand }) {};
+/** Routed `SubmissionLedger.recordChildSettled` — the child→parent durable notification. */
+var LedgerRecordChildSettledCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerRecordChildSettledCall")("LedgerRecordChildSettled", { request: ChildSettledNotification }) {};
+/** Routed `ThreadStore.materialize` against the owning Object. */
+var StoreMaterializeCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreMaterializeCall")("StoreMaterialize", { request: ThreadMaterialization }) {};
+/** Routed `ThreadStore.append` against the owning Object. */
+var StoreAppendCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreAppendCall")("StoreAppend", { request: FencedAppendRequest }) {};
+/** Routed one-page `ThreadStore.read`; the page bound is the request's own `limit`. */
+var StoreReadPageCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreReadPageCall")("StoreReadPage", { request: ThreadRead }) {};
+/** Routed `ThreadStore.inspectTail` against the owning Object. */
+var StoreInspectTailCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreInspectTailCall")("StoreInspectTail", { request: ThreadTailRequest }) {};
+/** Routed `ThreadStore.export` against the owning Object. */
+var StoreExportCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreExportCall")("StoreExport", { request: ThreadExportRequest }) {};
+/** Every request that may cross a Durable Object boundary — the CLOSED route-capable subset. */
+const PortRequest = Schema.Union([
+	LedgerAdmitCall,
+	LedgerMarkReadyCall,
+	LedgerLookupCall,
+	LedgerResolveAdmissionCall,
+	LedgerRequestAbortCall,
+	LedgerRecordChildSettledCall,
+	StoreMaterializeCall,
+	StoreAppendCall,
+	StoreReadPageCall,
+	StoreInspectTailCall,
+	StoreExportCall
+]);
+var LedgerAdmitResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerAdmitResult")("LedgerAdmitResult", { result: AdmissionResult }) {};
+var LedgerMarkReadyResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerMarkReadyResult")("LedgerMarkReadyResult", {}) {};
+/** `submission` is absent exactly when the lookup answered `Option.none`. */
+var LedgerLookupResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerLookupResult")("LedgerLookupResult", { submission: Schema.optionalKey(SubmissionSnapshot) }) {};
+var LedgerResolveAdmissionResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerResolveAdmissionResult")("LedgerResolveAdmissionResult", { resolution: AdmissionResolution }) {};
+var LedgerRequestAbortResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerRequestAbortResult")("LedgerRequestAbortResult", { intent: AbortIntent }) {};
+var LedgerRecordChildSettledResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerRecordChildSettledResult")("LedgerRecordChildSettledResult", { outcome: ChildSettledOutcome }) {};
+var StoreMaterializeResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreMaterializeResult")("StoreMaterializeResult", {}) {};
+var StoreAppendResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreAppendResult")("StoreAppendResult", { result: AppendResult }) {};
+/** One page of canonical records, bounded by the request's `limit` (≤ 1,024). */
+var StoreReadPageResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreReadPageResult")("StoreReadPageResult", { records: Schema.Array(CanonicalRecordEnvelope).check(Schema.isMaxLength(1024)) }) {};
+var StoreInspectTailResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreInspectTailResult")("StoreInspectTailResult", { tail: ThreadTail }) {};
+var StoreExportResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreExportResult")("StoreExportResult", { export: ThreadExport }) {};
+/** Every successful routed result. Callers narrow by the tag their request implies. */
+const PortResult = Schema.Union([
+	LedgerAdmitResult,
+	LedgerMarkReadyResult,
+	LedgerLookupResult,
+	LedgerResolveAdmissionResult,
+	LedgerRequestAbortResult,
+	LedgerRecordChildSettledResult,
+	StoreMaterializeResult,
+	StoreAppendResult,
+	StoreReadPageResult,
+	StoreInspectTailResult,
+	StoreExportResult
+]);
+/**
+* Every typed failure a route-capable operation can produce on its owning Object, plus the
+* protocol's own `PortProtocolError`. Members re-decode to the SAME tagged classes the
+* thread ports declare, so a routed caller observes identical error tags and fields.
+*/
+const PortFailure = Schema.Union([
+	AdmissionConflict,
+	AdmissionPolicyError,
+	SettlementConflict,
+	JoinedToHost,
+	LedgerError,
+	ThreadStoreError,
+	ThreadNotMaterialized,
+	AppendConflict,
+	FenceRejected,
+	PortProtocolError
+]);
+/** The routed operation succeeded on its owning Object. */
+var PortSucceeded = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/PortSucceeded")("PortSucceeded", { result: PortResult }) {};
+/** The routed operation failed TYPED on its owning Object; the failure re-decodes verbatim. */
+var PortFailed = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/PortFailed")("PortFailed", { failure: PortFailure }) {};
+/** The uniform answer of one `portCall`: op-specific success or a re-decodable typed failure. */
+const PortResponse = Schema.Union([PortSucceeded, PortFailed]);
+const encodePortRequest = Schema.encodeEffect(PortRequest);
+const decodePortRequest = Schema.decodeUnknownEffect(PortRequest);
+const encodePortResponse = Schema.encodeEffect(PortResponse);
+const decodePortResponse = Schema.decodeUnknownEffect(PortResponse);
+//#endregion
+export { LedgerAdmitCall, LedgerAdmitResult, LedgerLookupCall, LedgerLookupResult, LedgerMarkReadyCall, LedgerMarkReadyResult, LedgerRecordChildSettledCall, LedgerRecordChildSettledResult, LedgerRequestAbortCall, LedgerRequestAbortResult, LedgerResolveAdmissionCall, LedgerResolveAdmissionResult, MAX_PORT_DIAGNOSTIC_LENGTH, PortFailed, PortFailure, PortProtocolError, PortRequest, PortResponse, PortResult, PortSucceeded, StoreAppendCall, StoreAppendResult, StoreExportCall, StoreExportResult, StoreInspectTailCall, StoreInspectTailResult, StoreMaterializeCall, StoreMaterializeResult, StoreReadPageCall, StoreReadPageResult, boundPortDiagnostic, decodePortRequest, decodePortResponse, encodePortRequest, encodePortResponse, PortProtocol_exports as t };
+
+//# sourceMappingURL=PortProtocol.mjs.map

package/dist/PortProtocol.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PortProtocol.mjs","names":[],"sources":["../src/PortProtocol.ts"],"sourcesContent":["import { Schema } from \"effect\";\nimport { CanonicalRecordEnvelope } from \"effect-agent/records\";\nimport {\n  AbortCommand,\n  AbortIntent,\n  AdmissionConflict,\n  AdmissionPolicyError,\n  AdmissionRequest,\n  AdmissionResolution,\n  AdmissionResult,\n  ChildSettledNotification,\n  ChildSettledOutcome,\n  JoinedToHost,\n  LedgerError,\n  MarkReadyRequest,\n  SettlementConflict,\n  SubmissionLookup,\n  SubmissionLookupByKey,\n  SubmissionSnapshot,\n} from \"effect-agent/submission-ledger\";\nimport {\n  AppendConflict,\n  AppendResult,\n  ThreadExport,\n  ThreadExportRequest,\n  ThreadMaterialization,\n  ThreadNotMaterialized,\n  ThreadRead,\n  ThreadStoreError,\n  ThreadTail,\n  ThreadTailRequest,\n  FenceRejected,\n  FencedAppendRequest,\n} from \"effect-agent/thread-store\";\n\n/**\n * The cross-Durable-Object port protocol (plan §1.3, D-P6-3): Schema request/response/error\n * envelopes for the CLOSED route-capable subset of the thread ports. One Thread's\n * Durable Object executes another Thread's request against its OWN local facets; the\n * envelopes here are the only values that cross the Object boundary, and they are\n * transport-agnostic — native Durable Object JS RPC is the shipped carrier, fetch-with-JSON\n * the documented fallback, and both move the same Schema-encoded JSON.\n *\n * The closed subset is exactly the set of operations the durable coordinator performs against\n * a FOREIGN Thread (parent/child establishment, status checks, abort propagation,\n * child-settlement notification, and the child-thread store operations used by\n * establishment, `verifySettledChild`, and result projection):\n *\n * - ledger: `admit`, `markReady`, `lookup`, `resolveAdmission`, `requestAbort`,\n *   `recordChildSettled`;\n * - store: `materialize`, `append`, `read` (one page), `inspectTail`, `export`.\n *\n * Every other port operation is lane-local and has no envelope. A foreign disposable\n * recovery-cache load returns a miss so the caller can replay canonical history. Other\n * foreign operations fail fast and typed instead of widening the distributed surface.\n *\n * Failures cross the boundary as the `PortFailure` union and re-decode on the caller side to\n * the SAME tagged error types the local facet would have produced, so routed calls keep\n * error-tag fidelity. `cause` chains inside `LedgerError`/`ThreadStoreError` travel as\n * Schema defects and do not claim instance fidelity across Objects (plan §2.8).\n */\n\n/** Ceiling for protocol diagnostic strings; matches `AdmissionIndeterminate.reason`. */\nexport const MAX_PORT_DIAGNOSTIC_LENGTH = 4_096;\n\nconst BoundedDiagnostic = Schema.String.check(Schema.isMaxLength(MAX_PORT_DIAGNOSTIC_LENGTH));\n\n/** Truncate a diagnostic string to the protocol's bounded diagnostic length. */\nexport const boundPortDiagnostic = (value: string): string =>\n  value.length > MAX_PORT_DIAGNOSTIC_LENGTH\n    ? `${value.slice(0, MAX_PORT_DIAGNOSTIC_LENGTH - 3)}...`\n    : value;\n\n/**\n * The envelope itself could not be honored: the receiving Object could not decode the\n * request, or a response could not be encoded/decoded. It never carries port semantics —\n * callers fold it into the operation's base error (`LedgerError`/`ThreadStoreError`),\n * except `resolveAdmission`, which folds it into `AdmissionIndeterminate` because a\n * non-answer is never proof of absence (SUB-031).\n */\nexport class PortProtocolError extends Schema.TaggedError<PortProtocolError>()(\n  \"PortProtocolError\",\n  {\n    message: BoundedDiagnostic,\n  },\n) {}\n\n// ---------------------------------------------------------------------------\n// Requests\n// ---------------------------------------------------------------------------\n\n/** Routed `SubmissionLedger.admit` — child establishment admits INTO the owning Object. */\nexport class LedgerAdmitCall extends Schema.TaggedClass<LedgerAdmitCall>(\n  \"@effect-agent/storage-cloudflare/LedgerAdmitCall\",\n)(\"LedgerAdmit\", {\n  request: AdmissionRequest,\n}) {}\n\n/** Routed `SubmissionLedger.markReady` for a Submission owned by another Object. */\nexport class LedgerMarkReadyCall extends Schema.TaggedClass<LedgerMarkReadyCall>(\n  \"@effect-agent/storage-cloudflare/LedgerMarkReadyCall\",\n)(\"LedgerMarkReady\", {\n  request: MarkReadyRequest,\n}) {}\n\n/** Routed `SubmissionLedger.lookup` (by identity or scoped idempotency key). */\nexport class LedgerLookupCall extends Schema.TaggedClass<LedgerLookupCall>(\n  \"@effect-agent/storage-cloudflare/LedgerLookupCall\",\n)(\"LedgerLookup\", {\n  request: SubmissionLookup,\n}) {}\n\n/** Routed `SubmissionLedger.resolveAdmission` — the SUB-031 tri-state authority call. */\nexport class LedgerResolveAdmissionCall extends Schema.TaggedClass<LedgerResolveAdmissionCall>(\n  \"@effect-agent/storage-cloudflare/LedgerResolveAdmissionCall\",\n)(\"LedgerResolveAdmission\", {\n  request: SubmissionLookupByKey,\n}) {}\n\n/** Routed `SubmissionLedger.requestAbort` — abort propagation across Objects. */\nexport class LedgerRequestAbortCall extends Schema.TaggedClass<LedgerRequestAbortCall>(\n  \"@effect-agent/storage-cloudflare/LedgerRequestAbortCall\",\n)(\"LedgerRequestAbort\", {\n  request: AbortCommand,\n}) {}\n\n/** Routed `SubmissionLedger.recordChildSettled` — the child→parent durable notification. */\nexport class LedgerRecordChildSettledCall extends Schema.TaggedClass<LedgerRecordChildSettledCall>(\n  \"@effect-agent/storage-cloudflare/LedgerRecordChildSettledCall\",\n)(\"LedgerRecordChildSettled\", {\n  request: ChildSettledNotification,\n}) {}\n\n/** Routed `ThreadStore.materialize` against the owning Object. */\nexport class StoreMaterializeCall extends Schema.TaggedClass<StoreMaterializeCall>(\n  \"@effect-agent/storage-cloudflare/StoreMaterializeCall\",\n)(\"StoreMaterialize\", {\n  request: ThreadMaterialization,\n}) {}\n\n/** Routed `ThreadStore.append` against the owning Object. */\nexport class StoreAppendCall extends Schema.TaggedClass<StoreAppendCall>(\n  \"@effect-agent/storage-cloudflare/StoreAppendCall\",\n)(\"StoreAppend\", {\n  request: FencedAppendRequest,\n}) {}\n\n/** Routed one-page `ThreadStore.read`; the page bound is the request's own `limit`. */\nexport class StoreReadPageCall extends Schema.TaggedClass<StoreReadPageCall>(\n  \"@effect-agent/storage-cloudflare/StoreReadPageCall\",\n)(\"StoreReadPage\", {\n  request: ThreadRead,\n}) {}\n\n/** Routed `ThreadStore.inspectTail` against the owning Object. */\nexport class StoreInspectTailCall extends Schema.TaggedClass<StoreInspectTailCall>(\n  \"@effect-agent/storage-cloudflare/StoreInspectTailCall\",\n)(\"StoreInspectTail\", {\n  request: ThreadTailRequest,\n}) {}\n\n/** Routed `ThreadStore.export` against the owning Object. */\nexport class StoreExportCall extends Schema.TaggedClass<StoreExportCall>(\n  \"@effect-agent/storage-cloudflare/StoreExportCall\",\n)(\"StoreExport\", {\n  request: ThreadExportRequest,\n}) {}\n\n/** Every request that may cross a Durable Object boundary — the CLOSED route-capable subset. */\nexport const PortRequest = Schema.Union([\n  LedgerAdmitCall,\n  LedgerMarkReadyCall,\n  LedgerLookupCall,\n  LedgerResolveAdmissionCall,\n  LedgerRequestAbortCall,\n  LedgerRecordChildSettledCall,\n  StoreMaterializeCall,\n  StoreAppendCall,\n  StoreReadPageCall,\n  StoreInspectTailCall,\n  StoreExportCall,\n]);\n\nexport type PortRequest = typeof PortRequest.Type;\n\n/** The wire form of one port request (what a transport actually carries). */\nexport type PortRequestEnvelope = typeof PortRequest.Encoded;\n\n// ---------------------------------------------------------------------------\n// Results\n// ---------------------------------------------------------------------------\n\nexport class LedgerAdmitResult extends Schema.TaggedClass<LedgerAdmitResult>(\n  \"@effect-agent/storage-cloudflare/LedgerAdmitResult\",\n)(\"LedgerAdmitResult\", {\n  result: AdmissionResult,\n}) {}\n\nexport class LedgerMarkReadyResult extends Schema.TaggedClass<LedgerMarkReadyResult>(\n  \"@effect-agent/storage-cloudflare/LedgerMarkReadyResult\",\n)(\"LedgerMarkReadyResult\", {}) {}\n\n/** `submission` is absent exactly when the lookup answered `Option.none`. */\nexport class LedgerLookupResult extends Schema.TaggedClass<LedgerLookupResult>(\n  \"@effect-agent/storage-cloudflare/LedgerLookupResult\",\n)(\"LedgerLookupResult\", {\n  submission: Schema.optionalKey(SubmissionSnapshot),\n}) {}\n\nexport class LedgerResolveAdmissionResult extends Schema.TaggedClass<LedgerResolveAdmissionResult>(\n  \"@effect-agent/storage-cloudflare/LedgerResolveAdmissionResult\",\n)(\"LedgerResolveAdmissionResult\", {\n  resolution: AdmissionResolution,\n}) {}\n\nexport class LedgerRequestAbortResult extends Schema.TaggedClass<LedgerRequestAbortResult>(\n  \"@effect-agent/storage-cloudflare/LedgerRequestAbortResult\",\n)(\"LedgerRequestAbortResult\", {\n  intent: AbortIntent,\n}) {}\n\nexport class LedgerRecordChildSettledResult extends Schema.TaggedClass<LedgerRecordChildSettledResult>(\n  \"@effect-agent/storage-cloudflare/LedgerRecordChildSettledResult\",\n)(\"LedgerRecordChildSettledResult\", {\n  outcome: ChildSettledOutcome,\n}) {}\n\nexport class StoreMaterializeResult extends Schema.TaggedClass<StoreMaterializeResult>(\n  \"@effect-agent/storage-cloudflare/StoreMaterializeResult\",\n)(\"StoreMaterializeResult\", {}) {}\n\nexport class StoreAppendResult extends Schema.TaggedClass<StoreAppendResult>(\n  \"@effect-agent/storage-cloudflare/StoreAppendResult\",\n)(\"StoreAppendResult\", {\n  result: AppendResult,\n}) {}\n\n/** One page of canonical records, bounded by the request's `limit` (≤ 1,024). */\nexport class StoreReadPageResult extends Schema.TaggedClass<StoreReadPageResult>(\n  \"@effect-agent/storage-cloudflare/StoreReadPageResult\",\n)(\"StoreReadPageResult\", {\n  records: Schema.Array(CanonicalRecordEnvelope).check(Schema.isMaxLength(1_024)),\n}) {}\n\nexport class StoreInspectTailResult extends Schema.TaggedClass<StoreInspectTailResult>(\n  \"@effect-agent/storage-cloudflare/StoreInspectTailResult\",\n)(\"StoreInspectTailResult\", {\n  tail: ThreadTail,\n}) {}\n\nexport class StoreExportResult extends Schema.TaggedClass<StoreExportResult>(\n  \"@effect-agent/storage-cloudflare/StoreExportResult\",\n)(\"StoreExportResult\", {\n  export: ThreadExport,\n}) {}\n\n/** Every successful routed result. Callers narrow by the tag their request implies. */\nexport const PortResult = Schema.Union([\n  LedgerAdmitResult,\n  LedgerMarkReadyResult,\n  LedgerLookupResult,\n  LedgerResolveAdmissionResult,\n  LedgerRequestAbortResult,\n  LedgerRecordChildSettledResult,\n  StoreMaterializeResult,\n  StoreAppendResult,\n  StoreReadPageResult,\n  StoreInspectTailResult,\n  StoreExportResult,\n]);\n\nexport type PortResult = typeof PortResult.Type;\n\n// ---------------------------------------------------------------------------\n// Failures and the response envelope\n// ---------------------------------------------------------------------------\n\n/**\n * Every typed failure a route-capable operation can produce on its owning Object, plus the\n * protocol's own `PortProtocolError`. Members re-decode to the SAME tagged classes the\n * thread ports declare, so a routed caller observes identical error tags and fields.\n */\nexport const PortFailure = Schema.Union([\n  AdmissionConflict,\n  AdmissionPolicyError,\n  SettlementConflict,\n  JoinedToHost,\n  LedgerError,\n  ThreadStoreError,\n  ThreadNotMaterialized,\n  AppendConflict,\n  FenceRejected,\n  PortProtocolError,\n]);\n\nexport type PortFailure = typeof PortFailure.Type;\n\n/** The routed operation succeeded on its owning Object. */\nexport class PortSucceeded extends Schema.TaggedClass<PortSucceeded>(\n  \"@effect-agent/storage-cloudflare/PortSucceeded\",\n)(\"PortSucceeded\", {\n  result: PortResult,\n}) {}\n\n/** The routed operation failed TYPED on its owning Object; the failure re-decodes verbatim. */\nexport class PortFailed extends Schema.TaggedClass<PortFailed>(\n  \"@effect-agent/storage-cloudflare/PortFailed\",\n)(\"PortFailed\", {\n  failure: PortFailure,\n}) {}\n\n/** The uniform answer of one `portCall`: op-specific success or a re-decodable typed failure. */\nexport const PortResponse = Schema.Union([PortSucceeded, PortFailed]);\nexport type PortResponse = typeof PortResponse.Type;\n\n/** The wire form of one port response (what a transport actually carries). */\nexport type PortResponseEnvelope = typeof PortResponse.Encoded;\n\n// ---------------------------------------------------------------------------\n// Codecs\n// ---------------------------------------------------------------------------\n\nexport const encodePortRequest = Schema.encodeEffect(PortRequest);\nexport const decodePortRequest = Schema.decodeUnknownEffect(PortRequest);\nexport const encodePortResponse = Schema.encodeEffect(PortResponse);\nexport const decodePortResponse = Schema.decodeUnknownEffect(PortResponse);\n"],"mappings":"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"}

package/dist/PortRouting.d.mts

@@ -0,0 +1,83 @@
+import { LedgerAdmitCall, LedgerLookupCall, LedgerMarkReadyCall, LedgerRecordChildSettledCall, LedgerRequestAbortCall, LedgerResolveAdmissionCall, PortFailed, PortRequestEnvelope, PortSucceeded, StoreAppendCall, StoreExportCall, StoreInspectTailCall, StoreMaterializeCall, StoreReadPageCall } from "./PortProtocol.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+import { ThreadMaterialization, ThreadStore } from "effect-agent/thread-store";
+import { SubmissionLedger } from "effect-agent/submission-ledger";
+declare namespace PortRouting_d_exports {
+  export { PortTransportError, RoutedPortOptions, ThreadPortTransport, executePortRequest, handleEncodedPortRequest, portTransportFailure, routedSubmissionLedgerLayer, routedThreadStoreLayer };
+}
+type ThreadId = ThreadMaterialization["threadId"];
+declare const PortTransportError_base: Schema.Class<PortTransportError, Schema.TaggedStruct<"PortTransportError", {
+  readonly target: Schema.String;
+  readonly message: Schema.String;
+  readonly retryable: Schema.optionalKey<Schema.Boolean>;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A transport could not deliver a port request to (or an answer from) the owning
+ * Thread's Durable Object. `retryable` carries the platform's own stub signal when one
+ * exists. This error never crosses the wire — it is the CALLER-side evidence that the
+ * authority was unreachable, which is exactly the case `AdmissionIndeterminate` was
+ * specified for (SUB-031).
+ */
+declare class PortTransportError extends PortTransportError_base {}
+/**
+ * Build a `PortTransportError` from an arbitrary thrown transport cause, preserving the
+ * platform stub's own `retryable` signal when present.
+ */
+declare const portTransportFailure: (target: string, cause: unknown) => PortTransportError;
+declare const ThreadPortTransport_base: Context.ServiceClass<ThreadPortTransport, "@effect-agent/storage-cloudflare/ThreadPortTransport", {
+  readonly call: (threadId: ThreadId, request: PortRequestEnvelope) => Effect.Effect<unknown, PortTransportError>;
+}>;
+/**
+ * Delivery of Schema-encoded port envelopes to the Durable Object that owns a FOREIGN
+ * Thread (plan §1.3, D-P6-3). The shipped implementation (platform-cloudflare, WP3)
+ * calls the owner's `portCall` over native Durable Object JS RPC via
+ * `namespace.idFromName(threadId)`; the protocol is transport-agnostic and any carrier
+ * that moves the encoded envelopes verbatim satisfies this service. Implementations MUST
+ * surface every delivery problem as `PortTransportError` and must never fabricate an answer.
+ */
+declare class ThreadPortTransport extends ThreadPortTransport_base {}
+/** Construction options shared by both routed port Layers. */
+interface RoutedPortOptions {
+  /**
+   * Decide whether this physical owner stores the addressed logical Thread. Local
+   * requests use the same SQLite facets; foreign requests use the transport or fail
+   * fast typed. The predicate determines placement, never caller authorization.
+   */
+  readonly ownsThread: (threadId: ThreadId) => boolean;
+}
+/**
+ * Routing decorator over the LOCAL `SubmissionLedger` facet (plan §1.3): a request addressing
+ * this Object's Thread executes locally; a route-capable request addressing another
+ * Thread is Schema-encoded onto the `ThreadPortTransport` and executed by the
+ * owning Object's local facet; any other foreign request fails fast typed. Provide the WP1
+ * local facet (`submissionLedgerLayer`/`ledgerLayer`) and a transport to close it.
+ */
+declare const routedSubmissionLedgerLayer: (options: RoutedPortOptions) => Layer.Layer<SubmissionLedger, never, SubmissionLedger | ThreadPortTransport>;
+/**
+ * Routing decorator over the LOCAL `ThreadStore` facet (plan §1.3): this-thread
+ * requests execute locally; foreign materialize/append/read/inspectTail/export travel the
+ * transport. Foreign recovery-cache loads return none for canonical replay; other foreign
+ * checkpoint operations and observation fail fast typed.
+ */
+declare const routedThreadStoreLayer: (options: RoutedPortOptions) => Layer.Layer<ThreadStore, never, ThreadStore | ThreadPortTransport>;
+/**
+ * Execute one decoded port request against THIS Object's LOCAL facets — the owner-side half
+ * of the routed ports (plan §1.3). Callers must provide the WP1 local facets, never the
+ * routed decorators: the routing layer already established that this Object owns the
+ * addressed Thread, and re-routing here could bounce a request between Objects.
+ * Failures never escape — every typed port failure becomes a `PortFailed` envelope that
+ * re-decodes on the caller side.
+ */
+declare const executePortRequest: (request: LedgerAdmitCall | LedgerLookupCall | LedgerMarkReadyCall | LedgerRecordChildSettledCall | LedgerRequestAbortCall | LedgerResolveAdmissionCall | StoreAppendCall | StoreExportCall | StoreInspectTailCall | StoreMaterializeCall | StoreReadPageCall) => Effect.Effect<PortFailed | PortSucceeded, never, SubmissionLedger | ThreadStore>;
+/**
+ * The complete owner-side endpoint body for `portCall` (D-P6-3): decode the wire request,
+ * execute it against this Object's LOCAL facets, and answer with the encoded response
+ * envelope. Total by construction — a request that cannot be decoded, or a response that
+ * cannot be encoded, answers `PortFailed(PortProtocolError)` instead of throwing, so the
+ * transport never has to interpret exceptions as protocol answers.
+ */
+declare const handleEncodedPortRequest: (encoded: unknown) => Effect.Effect<unknown, never, SubmissionLedger | ThreadStore>;
+//#endregion
+export { PortTransportError, RoutedPortOptions, ThreadPortTransport, executePortRequest, handleEncodedPortRequest, portTransportFailure, routedSubmissionLedgerLayer, routedThreadStoreLayer, PortRouting_d_exports as t };
+//# sourceMappingURL=PortRouting.d.mts.map