@effect-agent/platform-cloudflare 0.1.0-beta.38 → 0.1.0-beta.39

package/dist/bindings-C00ZfjsX.d.mts

@@ -0,0 +1,100 @@
+import { Context, Effect, Layer, Schema } from "effect";
+import { ProducerId } from "@effect-agent/thread";
+import { ThreadId } from "@effect-agent/core";
+//#region src/bindings.d.ts
+declare const CloudflareBindingError_base: Schema.Class<CloudflareBindingError, Schema.TaggedStruct<"CloudflareBindingError", {
+  readonly binding: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Cloudflare platform bindings as Effect services (DEPLOY-010: "Cloudflare platform bindings
+ * are supplied as Effect services/Layers"). Application code never reads `env` or touches a
+ * `DurableObjectState` directly — the Thread Object class constructs these Layers once
+ * per incarnation and everything downstream consumes the services.
+ */
+/** A Cloudflare platform binding was missing or carried the wrong shape (DEPLOY-003/010). */
+declare class CloudflareBindingError extends CloudflareBindingError_base {}
+/**
+ * The RPC surface one Thread Durable Object exposes to Workers and to sibling
+ * Thread Objects. `ThreadObject.make` implements it; the Worker-side client
+ * and the cross-Object transport call it through `DurableObjectNamespace` stubs. Every
+ * `encoded` value is a Schema-encoded envelope (`client.ts` wire schemas for host entry
+ * points, `@effect-agent/storage-cloudflare` port envelopes for `portCall`), so the RPC
+ * boundary carries only structured-cloneable JSON. The optional trailing trace context is
+ * transient native RPC metadata, stripped by an opted-in effect-cf receiver before decoding
+ * the host envelope. It never enters durable state.
+ */
+interface ThreadObjectRpc extends Rpc.DurableObjectBranded {
+  /** Admission-limits gate + `DurableAgentRuntime.submit`; answers a `SubmitResponse`. */
+  submitEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  /** Wake-hinted, poll-guaranteed settlement wait; answers an `AwaitSettlementResponse`. */
+  awaitSettlementEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  /** Event-driven durable progress wait; answers a `ProgressObserved` host response. */
+  awaitProgressEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  /** Best-effort cancellation for one in-flight progress wait. */
+  cancelProgressEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  /** One bounded page of canonical records; answers an `ObservePageResponse`. */
+  observePage(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  /** Durable abort intent; answers an `AbortResponse`. */
+  abortEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  /** Durable approval decision (plan §2.6); answers a `ResolveApprovalResponse`. */
+  resolveApprovalEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  /** Authorized DUR-017 Unknown-Outcome resolution; answers a `ResolveUnknownResponse`. */
+  resolveUnknownEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  /** Owner-side cross-Object port endpoint (WP2 envelopes, executed on LOCAL facets). */
+  portCall(encoded: unknown): Promise<unknown>;
+  /** Droppable liveness hint from another Object: arms an immediate alarm. */
+  wake(): Promise<void>;
+}
+declare const ThreadObjectNamespace_base: Context.ServiceClass<ThreadObjectNamespace, "@effect-agent/platform-cloudflare/ThreadObjectNamespace", {
+  readonly namespace: DurableObjectNamespace<ThreadObjectRpc>;
+  /** Stable binding name for opted-in native RPC tracing; absent by default. */
+  readonly rpcTracing?: string;
+}>;
+/**
+ * The `DurableObjectNamespace` binding that addresses Thread Objects. The Object
+ * identity rule is `namespace.idFromName(threadId)` (plan §1.2): Thread IDs are
+ * globally unique, so the mapping is total and deterministic and no directory service exists.
+ */
+declare class ThreadObjectNamespace extends ThreadObjectNamespace_base {
+  static layer(namespace: DurableObjectNamespace<ThreadObjectRpc>): Layer.Layer<ThreadObjectNamespace>;
+}
+/**
+ * Narrow one `env` member to a `DurableObjectNamespace`. `env` is an untyped platform value,
+ * and a namespace binding is a host object no Schema can decode, so this is the documented
+ * narrowest-boundary check (structural probe for the namespace surface the transport uses);
+ * a missing or misshaped binding fails typed before any Layer is built.
+ */
+declare const threadNamespaceFromEnv: (env: unknown, binding: string) => Effect.Effect<DurableObjectNamespace<ThreadObjectRpc>, CloudflareBindingError, never>;
+/**
+ * Build the namespace from Worker `env` (fails typed). Enable `rpcTracing` only when the
+ * receiver also opts into the effect-cf native RPC trace-context contract.
+ */
+declare const threadNamespaceLayer: (env: unknown, binding: string, options?: {
+  readonly rpcTracing?: boolean;
+}) => Layer.Layer<ThreadObjectNamespace, CloudflareBindingError>;
+declare const DurableObjectContext_base: Context.ServiceClass<DurableObjectContext, "@effect-agent/platform-cloudflare/DurableObjectContext", {
+  readonly ctx: DurableObjectState;
+  readonly env: unknown;
+}>;
+/**
+ * The live Durable Object execution context of THIS incarnation. Only Layer construction and
+ * the alarm service consume it; important state never lives on it (`ctx.storage` is truth,
+ * everything in memory is a cache — deployment spec §11).
+ */
+declare class DurableObjectContext extends DurableObjectContext_base {
+  static layer(ctx: DurableObjectState, env: unknown): Layer.Layer<DurableObjectContext>;
+}
+declare const ThreadObjectIdentity_base: Context.ServiceClass<ThreadObjectIdentity, "@effect-agent/platform-cloudflare/ThreadObjectIdentity", {
+  readonly threadId: ThreadId;
+  readonly producerId: ProducerId;
+}>;
+/**
+ * The Thread identity this Object serializes and the producer identity its Attempts
+ * write with (`{producerPrefix}:{threadId}`, plan §1.4). Derived once per incarnation
+ * from `ctx.id.name` — the Object identity rule guarantees the name IS the Thread ID.
+ */
+declare class ThreadObjectIdentity extends ThreadObjectIdentity_base {}
+//#endregion
+export { ThreadObjectRpc as a, ThreadObjectNamespace as i, DurableObjectContext as n, threadNamespaceFromEnv as o, ThreadObjectIdentity as r, threadNamespaceLayer as s, CloudflareBindingError as t };
+//# sourceMappingURL=bindings-C00ZfjsX.d.mts.map