@yielded/agent-platform-cloudflare 0.0.0-stage → 0.1.0-beta.166

package/dist/Alarm.d.mts

@@ -0,0 +1,267 @@
+import { DurableObjectContext } from "./CloudflareBindings.mjs";
+import { s as CloudflareDurableRuntimeConfig } from "./CloudflareConfig-qDrRLofL.mjs";
+import { DurableBindingFailure } from "@yielded/agent/agent-registration";
+import { DurableAgentRuntime, DurableRuntimeConfig, DurableWorkerFailure, RecoveryFailure } from "@yielded/agent/durable-agent-runtime";
+import { SubmissionLedger } from "@yielded/agent/submission-ledger";
+import { ThreadProjectionError, ThreadProjectionMaintenance } from "@yielded/agent/thread-projection-maintenance";
+import { WakeScheduler } from "@yielded/agent/wake-scheduler";
+import { Cause, Context, Effect, Layer, Option, Schema, Scope } from "effect";
+import { SqlClient } from "effect/sql/SqlClient";
+import { SqlError } from "effect/sql/SqlError";
+declare namespace Alarm_d_exports {
+  export { DurableAlarmError, DurableAlarmService, MaintenancePassFailure, MaintenancePassReport, ThreadHostMaintenance, ThreadHostMaintenanceLane, ThreadMaintenance, ThreadMaintenanceFailpoint, ThreadMaintenanceFailpointHandler, ThreadMaintenanceFailpointLocation, ThreadMessageDelivery, ThreadMutationGate, ThreadNativeMaintenance, ThreadPublication, ThreadPublicationService, ThreadRecoveryEvents, ThreadRecoveryFaultEvent, publishCommitted };
+}
+declare const DurableAlarmError_base: Schema.Class<DurableAlarmError, Schema.TaggedStruct<"DurableAlarmError", {
+  readonly operation: Schema.String;
+  readonly message: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, Cause.YieldableError>;
+/**
+ * The single multiplexed Durable Object alarm (decision D-P6-2). A Durable Object has ONE
+ * alarm slot; due work (lease expiry, settlement
+ * and abort re-checks, retry backoff) multiplexes into one idempotent maintenance pass, and
+ * the slot always holds the EARLIEST deadline any caller asked for.
+ *
+ * The alarm invariant (plan §1.4): every committed actionable mutation carries a newer durable
+ * maintenance generation and a committed alarm. Stable externally-driven waits may be
+ * nonterminal without retaining an alarm; their resolving mutation advances the generation and
+ * restores the alarm atomically.
+ */
+/** The Durable Object alarm API failed; surfaces on host entry points as a typed refusal. */
+export declare class DurableAlarmError extends DurableAlarmError_base {}
+declare const DurableAlarmService_base: Context.ServiceClass<DurableAlarmService, "@effect-agent/platform-cloudflare/DurableAlarmService", {
+  /** The scheduled deadline in epoch milliseconds, if any. */
+  readonly scheduled: Effect.Effect<Option.Option<number>, DurableAlarmError>;
+  /** Replace the slot with this deadline. */
+  readonly scheduleAt: (epochMillis: number) => Effect.Effect<void, DurableAlarmError>;
+  /** Keep the EARLIER of the existing deadline and this one (the multiplexing rule). */
+  readonly ensureScheduledBy: (epochMillis: number) => Effect.Effect<void, DurableAlarmError>;
+  /**
+   * Arm an immediate alarm (the durable, coalescing local wake) — DEFERRED while a
+   * maintenance pass is executing. Workerd cancels an in-flight alarm handler when a new
+   * EARLIER deadline is written during its execution (`requestScheduledAlarm`), and the
+   * maintenance pass runs INSIDE the alarm handler: an immediate wake landing mid-pass
+   * (a routed port mutation, a sibling's `wake()`, the coordinator's own local notify)
+   * would kill the running Attempt — manufacturing an ownership loss no real eviction
+   * caused, and routing open uncertain-class Tool Calls into spurious Unknown Outcomes.
+   * Deferral is contract-safe: wakes are droppable hints, every mutating entry point
+   * pre-arms BEFORE its first durable mutation (the alarm invariant never rests on this
+   * call). The pass's durable generation check observes any racing mutation, so the
+   * in-memory hint does not need to be flushed after a stable wait is acknowledged.
+   */
+  readonly scheduleNow: Effect.Effect<void, DurableAlarmError>;
+  /**
+   * Run one maintenance pass with wake deferral (see `scheduleNow`). Calls made while `body`
+   * executes are droppable promptness hints; correctness rests on the durable generation.
+   */
+  readonly withWakesDeferred: <A, E, R>(body: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+  /** Clear the slot; correctness-sensitive clears live in maintenance generation transactions. */
+  readonly cancel: Effect.Effect<void, DurableAlarmError>;
+}>;
+/** Native `ctx.storage` alarm slot owned by ThreadMaintenance; storage is truth. */
+export declare class DurableAlarmService extends DurableAlarmService_base {
+  static readonly layer: Layer.Layer<DurableAlarmService, never, DurableObjectContext | SqlClient>;
+}
+declare const MaintenancePassReport_base: Schema.Class<MaintenancePassReport, Schema.Struct<{
+  /** `caught-up` ran no runtime work (publication may be pending); `actionable` ran recovery. */
+  readonly phase: Schema.Literals<readonly ["caught-up", "actionable"]>;
+  /** Recovery decisions and Thread faults observed during this event. */
+  readonly recovered: Schema.Int;
+  /** Head Attempts settled during the event. Joined input may settle with each head. */
+  readonly settled: Schema.Int;
+  /** Submissions still nonterminal after the pass (suspended/unknown lanes stay honest). */
+  readonly nonterminal: Schema.Int;
+  /** `rearmed` for dirty/autonomous work, `cleared` for stable waits or settlement. */
+  readonly alarm: Schema.Literals<readonly ["rearmed", "cleared"]>;
+}>, {}>;
+/** What one maintenance pass did — auditable evidence mirroring `NodeDurableHost`'s report. */
+export declare class MaintenancePassReport extends MaintenancePassReport_base {}
+/** Fault boundaries around every maintenance-owned durable mutation. */
+export type ThreadMaintenanceFailpointLocation = "maintenance:dirty:before" | "maintenance:dirty:after" | "maintenance:mutation:armed" | "maintenance:mutation:finished" | "maintenance:ensure:before" | "maintenance:ensure:after" | "maintenance:begin:before" | "maintenance:begin:after" | "maintenance:select:before" | "maintenance:select:after" | "maintenance:binding-retry:before" | "maintenance:binding-retry:after" | "maintenance:recovery-status:before" | "maintenance:recovery-status:after" | "maintenance:retry:before" | "maintenance:retry:after" | "maintenance:checkpoint:before" | "maintenance:checkpoint:after" | "maintenance:finish:before" | "maintenance:finish:after";
+export type ThreadMaintenanceFailpointHandler = (location: ThreadMaintenanceFailpointLocation) => Effect.Effect<void>;
+declare const ThreadMaintenanceFailpoint_base: Context.ServiceClass<ThreadMaintenanceFailpoint, "@effect-agent/platform-cloudflare/ThreadMaintenanceFailpoint", {
+  readonly hit: ThreadMaintenanceFailpointHandler;
+}>;
+/** Test-only fault authority; production uses the inert layer. */
+export declare class ThreadMaintenanceFailpoint extends ThreadMaintenanceFailpoint_base {
+  static readonly layer: Layer.Layer<ThreadMaintenanceFailpoint, never, never>;
+}
+/**
+ * Durable host publication of canonical records and ledger approval/abort/resolution intents.
+ * The host owns schema-versioned cursors, destination idempotency and acknowledgement. Delivery
+ * is at least once. Hooks must not write the alarm slot or mutate the supplied raw source ports.
+ *
+ * `invalidate` and `prepareGeneration` must be bounded local operations.
+ * `prepareGeneration` durably invalidates a scan only when its generation changes; repeated
+ * calls must preserve partial scan progress. It runs with no source mutation in flight.
+ * Use this gate only for publication required before dependent native execution. Independent
+ * UI relays and outboxes belong to ThreadHostMaintenance.
+ * `drain` performs bounded delivery and returns its next deadline (None when caught up),
+ * after persisting receipts and retries. A pending deadline
+ * defers runtime recovery/Attempts, allowing committed host publications to drain first.
+ * Unexpected hook failures leave the prearmed generation for retry. Hooks acquire per-call
+ * resources with Effect.scoped; Layer construction owns incarnation resources (eviction need
+ * not run finalizers). Do not hold a local hook behind network I/O or call back into producers.
+ */
+export interface ThreadPublicationService {
+  readonly invalidate: Effect.Effect<void, DurableAlarmError>;
+  readonly prepareGeneration: (generation: bigint) => Effect.Effect<void, DurableAlarmError>;
+  readonly drain: Effect.Effect<Option.Option<number>, DurableAlarmError>;
+}
+declare const ThreadPublication_base: Context.ServiceClass<ThreadPublication, "@effect-agent/platform-cloudflare/ThreadPublication", ThreadPublicationService>;
+/** Opt in with `ThreadObject.layer(registrations, { publication: Layer.effect(ThreadPublication)(...) })`. */
+export declare class ThreadPublication extends ThreadPublication_base {
+  static readonly layer: Layer.Layer<ThreadPublication, never, never>;
+}
+/**
+ * Host-assembled native message recovery. Preparation is a bounded local selection; the
+ * driver bounds each actual Claim and persists its timeout/retry before `run` returns.
+ * The alarm must not add a timer starting at selection: Claim setup and retry commits belong
+ * to the driver. The prepared allowance decides only whether a wave fits this event.
+ */
+export declare const ThreadMessageDelivery: Context.Reference<{
+  readonly prepare: Effect.Effect<{
+    readonly timeoutMillis: number;
+    readonly run: Effect.Effect<Option.Option<number>, DurableAlarmError>;
+  }, DurableAlarmError>;
+}>;
+/**
+ * One explicitly scheduled application obligation. IDs are stable and unique within the
+ * physical Object; the `@yielded/agent:` prefix is reserved. There is no initial host wave.
+ * Producers enroll only affected IDs through ThreadMutationGate.withMutation({ lanes })
+ * or schedule(id, dueAt). A lane returns its next epoch-millisecond deadline (None = idle)
+ * with its finite wave, after persisting claims, receipts and retries. No deadline callback
+ * or polling is used. A racing producer keeps its newer revision due.
+ *
+ * The 1..300000ms allowance includes selection, dispatch, commits and scoped cleanup.
+ * Failed waves retain independent backoff and are not retried in the same event. Delivery
+ * remains at least once: persist exact envelopes and deduplicate by domain receipt identity.
+ * Hooks never write the alarm slot. Required execution gates belong to ThreadPublication.
+ */
+export interface ThreadHostMaintenanceLane {
+  readonly id: string;
+  /** Omission runs concurrently with native work. After-native lanes get one due wave
+   * after all admitted native Attempts and their scoped cleanup, even on native failure.
+   * They share the event deadline and remain inside the maintenance pass permit.
+   * Newly enrolled concurrent work yields this phase after scoped cleanup; unfinished
+   * waves retain their due revision and domain receipts for the next alarm.
+   */
+  readonly phase?: "concurrent" | "after-native";
+  readonly dispatchTimeoutMillis: number;
+  readonly run: Effect.Effect<Option.Option<number>, DurableAlarmError, Scope.Scope>;
+}
+/** Independent lanes share the existing alarm; compose hosts by concatenating their lanes. */
+export declare const ThreadHostMaintenance: Context.Reference<{
+  readonly lanes: ReadonlyArray<ThreadHostMaintenanceLane>;
+}>;
+/** @internal Framework handlers are separate from host registrations and their namespace. */
+export declare const ThreadNativeMaintenance: Context.Reference<{
+  readonly lanes: ReadonlyArray<ThreadHostMaintenanceLane>;
+}>;
+/** @internal Required host publication only; native lifecycle facts use a maintenance lane. */
+export declare const publishCommitted: Effect.Effect<void, never, ThreadPublication>;
+declare const ThreadRecoveryFaultEvent_base: Schema.Class<ThreadRecoveryFaultEvent, Schema.Struct<{
+  readonly schemaVersion: Schema.Literal<1>;
+  /** Monotonic within the physical Object; retained unchanged on delivery retries. */
+  readonly sequence: Schema.BigIntFromString;
+  readonly transition: Schema.Literals<readonly ["created", "changed", "cleared"]>;
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly occurredAt: Schema.Finite;
+  readonly firstFailedAt: Schema.Finite;
+  /** The current failure, or the last failure for a cleared event. */
+  readonly failure: typeof RecoveryFailure;
+}>, {}>;
+/** A committed recovery transition for one affected Submission; never a Settlement. */
+export declare class ThreadRecoveryFaultEvent extends ThreadRecoveryFaultEvent_base {}
+declare const ThreadRecoveryEvents_base: Context.ServiceClass<ThreadRecoveryEvents, "@effect-agent/platform-cloudflare/ThreadRecoveryEvents", {
+  readonly publish: (event: ThreadRecoveryFaultEvent) => Effect.Effect<void, DurableAlarmError>;
+}>;
+/**
+ * Ordered, at-least-once delivery through the existing host maintenance lane. Return only
+ * after durably applying the event or retaining it in a host outbox. Deduplicate by physical
+ * Object and sequence; callbacks may repeat after interruption. This is a trusted host hook,
+ * not pre-authorized UI data: the host owns recipient authorization and safe presentation.
+ * Capture services in the Layer. Do not call producers or write the raw alarm slot.
+ */
+export declare class ThreadRecoveryEvents extends ThreadRecoveryEvents_base {}
+declare const ThreadMutationGate_base: Context.ServiceClass<ThreadMutationGate, "@effect-agent/platform-cloudflare/internal/ThreadMutationGate", {
+  /** Commit source facts and their scheduling intent together. The flush runs before
+   * native commit; failed or interrupted transactions discard their queue view. */
+  readonly withTransaction: <A, E, R>(body: Effect.Effect<A, E, R>) => Effect.Effect<A, E | SqlError, R>;
+  readonly withMutation: <A, E, R>(body: Effect.Effect<A, E, R>,
+  /**
+   * Call outside SQL transactions so prearming commits before the body runs.
+   * Native admission, approval, abort and unknown resolution keep the default true.
+   * Host producers use false and name only the lanes for which they create work.
+   * Receipt-only bookkeeping with no new obligation names no lanes. Enrollment preserves
+   * a pending retry budget; idle completion or actual source progress replenishes it.
+   * Actual new work must record that progress in its source transaction, so a commit
+   * after parking cannot be stranded by eviction before this body returns.
+   */
+  options?: {
+    readonly invalidatesRecovery?: boolean;
+    readonly lanes?: ReadonlyArray<string>;
+  }) => Effect.Effect<A, E | DurableAlarmError, R>;
+  /** Enroll a known lane without accelerating its retry floor. A strictly increasing
+   * source cursor replenishes its budget; equal/older notices are replayed hints.
+   * Cursors identify committed source facts, never clocks, attempts or retry counters.
+   * Local sources call inside their source transaction. Remote sources retain the cursor
+   * notice with their work and retry delivery here; this call atomically accepts that
+   * notice and its alarm. Prearming alone cannot fence a later remote commit. */
+  readonly schedule: (id: string, dueAt: number, progressCursor?: bigint) => Effect.Effect<void, DurableAlarmError>;
+  /** Record an actual new fact inside its local source SQL transaction. The source
+   * transaction owns duplicate detection. Claims, lease renewals and retries are not progress.
+   * Also enrolls the lanes selected by this producer's enclosing withMutation boundary. */
+  readonly recordProgress: (lanes: ReadonlyArray<string>) => Effect.Effect<void, DurableAlarmError>;
+  /** In-incarnation notification; the durable due queue is the recovery authority. */
+  readonly activeLanes: Effect.Effect<ReadonlySet<string>>;
+  readonly revision: Effect.Effect<number>;
+  readonly awaitChange: (revision: number) => Effect.Effect<void>;
+  readonly withSnapshot: <A, E, R>(body: (active: number) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+}>;
+export declare class ThreadMutationGate extends ThreadMutationGate_base {
+  static readonly layer: Layer.Layer<ThreadMutationGate, DurableAlarmError, CloudflareDurableRuntimeConfig | DurableObjectContext | SqlClient | ThreadMaintenanceFailpoint>;
+}
+export type MaintenancePassFailure = DurableWorkerFailure | DurableBindingFailure | DurableAlarmError | ThreadProjectionError;
+declare const ThreadMaintenance_base: Context.ServiceClass<ThreadMaintenance, "@effect-agent/platform-cloudflare/ThreadMaintenance", {
+  /** One idempotent pass; failures propagate after durably scheduling bounded recovery. */
+  readonly pass: Effect.Effect<MaintenancePassReport, MaintenancePassFailure>;
+  /**
+   * Constructor gate: initialize/inspect only the O(1) maintenance record and ensure a dirty
+   * generation has an alarm. It never scans the ledger or canonical history.
+   */
+  readonly ensureAlarm: Effect.Effect<void, MaintenancePassFailure>;
+  /**
+   * Serialize the pre-arm boundary with pass acknowledgement, advance the durable dirty
+   * generation and arm the alarm in one transaction BEFORE running the caller's mutation.
+   * A pass cannot acknowledge while that mutation remains in flight.
+   */
+  readonly withMutation: <A, E, R>(body: Effect.Effect<A, E, R>) => Effect.Effect<A, E | DurableAlarmError, R>;
+}>;
+/**
+ * Incremental, quiescent maintenance over a durable dirty/processed generation (issue #93).
+ *
+ * One physical event owns native scheduling, auxiliary delivery and final alarm rearming.
+ *
+ * 1. Prearm before any work. A caught-up native step uses the O(1) generation record without
+ *    recovery, ledger scans or canonical-history reads.
+ * 2. Reconcile before each head Attempt, then checkpoint only the observed generation. A racing
+ *    producer keeps its generation dirty and immediately eligible. Quiescent native retries
+ *    retain their durable backoff.
+ * 3. Admit at most two independent Thread Attempts, one active head per Thread.
+ *    Keep native and delivery admission open together while finite waves remain active, so
+ *    fresh replies and abort controls can progress during unrelated cleanup. Close atomically
+ *    at quiescence, or at the original ten-minute yield deadline, then join admitted waves.
+ * 4. Native message delivery retains its driver-owned Claim deadline. Host/backfill waves are
+ *    bounded independently; incoming native work never restarts or cancels their attempts.
+ *    Auxiliary failures are reported after the current native opportunity.
+ * 5. Close every event resource before the final gated deadline snapshot and alarm decision.
+ *    The whole event retains one fourteen-minute cooperative timeout.
+ */
+export declare class ThreadMaintenance extends ThreadMaintenance_base {
+  static readonly layer: Layer.Layer<ThreadMaintenance, DurableAlarmError, ThreadMutationGate | ThreadPublication | ThreadProjectionMaintenance | DurableAgentRuntime | DurableRuntimeConfig | SubmissionLedger | WakeScheduler | DurableAlarmService | ThreadMaintenanceFailpoint | CloudflareDurableRuntimeConfig | DurableObjectContext | SqlClient>;
+}
+//#endregion
+export { Alarm_d_exports as t };
+//# sourceMappingURL=Alarm.d.mts.map

package/dist/Alarm.mjs

@@ -0,0 +1,2 @@
+import { a as ThreadHostMaintenance, c as ThreadMessageDelivery, d as ThreadPublication, f as ThreadRecoveryEvents, i as MaintenancePassReport, l as ThreadMutationGate, m as publishCommitted, n as DurableAlarmError, o as ThreadMaintenance, p as ThreadRecoveryFaultEvent, r as DurableAlarmService, s as ThreadMaintenanceFailpoint, u as ThreadNativeMaintenance } from "./Alarm-B0ODr1NE.mjs";
+export { DurableAlarmError, DurableAlarmService, MaintenancePassReport, ThreadHostMaintenance, ThreadMaintenance, ThreadMaintenanceFailpoint, ThreadMessageDelivery, ThreadMutationGate, ThreadNativeMaintenance, ThreadPublication, ThreadRecoveryEvents, ThreadRecoveryFaultEvent, publishCommitted };

package/dist/BrowserCredentials.d.mts

@@ -0,0 +1,91 @@
+import { Context, Effect, Schema } from "effect";
+declare namespace BrowserCredentials_d_exports {
+  export { BrowserCredentialAccess, BrowserCredentialMaterial, CardCredential, CredentialAccessError, CredentialAccessRequest, CredentialDispatch, CredentialFieldRole, CredentialFillError, CredentialFillResult, CredentialKind, CredentialOrigin, CredentialTarget, FillCredentialRequest, LoginCredential };
+}
+export declare const CredentialKind: Schema.Literals<readonly ["login", "card"]>;
+export declare const CredentialFieldRole: Schema.Literals<readonly ["username", "password", "card-name", "card-number", "card-expiry", "card-expiry-month", "card-expiry-year", "card-security-code"]>;
+/** Canonical HTTPS origins, including non-default ports. Grants must match exactly. */
+export declare const CredentialOrigin: Schema.String;
+declare const CredentialTarget_base: Schema.Class<CredentialTarget, Schema.Struct<{
+  readonly topOrigin: Schema.String;
+  readonly frameOrigin: Schema.String;
+  readonly recipientOrigin: Schema.String;
+}>, {}>;
+export declare class CredentialTarget extends CredentialTarget_base {}
+declare const FillCredentialRequest_base: Schema.Class<FillCredentialRequest, Schema.Struct<{
+  readonly credential: Schema.NonEmptyString;
+  readonly kind: Schema.Literals<readonly ["login", "card"]>;
+  readonly frame: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+  readonly fields: Schema.$Array<Schema.Struct<{
+    readonly selector: Schema.NonEmptyString;
+    readonly role: Schema.Literals<readonly ["username", "password", "card-name", "card-number", "card-expiry", "card-expiry-month", "card-expiry-year", "card-security-code"]>;
+  }>>;
+}>, {}>;
+/** Selectors identify one native form. Roles explicitly select material; no field inference occurs. */
+export declare class FillCredentialRequest extends FillCredentialRequest_base {}
+/** Host-only material. Never return or encode it through a Tool, log, trace, or checkpoint. */
+export declare const LoginCredential: Schema.TaggedStruct<"LoginCredential", {
+  readonly username: Schema.Redacted<Schema.NonEmptyString>;
+  readonly password: Schema.Redacted<Schema.NonEmptyString>;
+}>;
+/** Security codes are transient; the host must not persist them. */
+export declare const CardCredential: Schema.TaggedStruct<"CardCredential", {
+  readonly name: Schema.Redacted<Schema.NonEmptyString>;
+  readonly number: Schema.Redacted<Schema.String>;
+  readonly expiry: Schema.Redacted<Schema.NonEmptyString>;
+  readonly expiryMonth: Schema.Redacted<Schema.String>;
+  readonly expiryYear: Schema.Redacted<Schema.String>;
+  readonly securityCode: Schema.optionalKey<Schema.Redacted<Schema.String>>;
+}>;
+export declare const BrowserCredentialMaterial: Schema.Union<readonly [Schema.TaggedStruct<"LoginCredential", {
+  readonly username: Schema.Redacted<Schema.NonEmptyString>;
+  readonly password: Schema.Redacted<Schema.NonEmptyString>;
+}>, Schema.TaggedStruct<"CardCredential", {
+  readonly name: Schema.Redacted<Schema.NonEmptyString>;
+  readonly number: Schema.Redacted<Schema.String>;
+  readonly expiry: Schema.Redacted<Schema.NonEmptyString>;
+  readonly expiryMonth: Schema.Redacted<Schema.String>;
+  readonly expiryYear: Schema.Redacted<Schema.String>;
+  readonly securityCode: Schema.optionalKey<Schema.Redacted<Schema.String>>;
+}>]>;
+export type BrowserCredentialMaterial = typeof BrowserCredentialMaterial.Type;
+declare const CredentialAccessError_base: Schema.Class<CredentialAccessError, Schema.TaggedStruct<"CredentialAccessError", {
+  readonly reason: Schema.Literals<readonly ["denied", "missing-credential", "needs-attention", "busy", "resolver"]>;
+}>, import("effect/Cause").YieldableError>;
+export declare class CredentialAccessError extends CredentialAccessError_base {}
+export interface CredentialAccessRequest {
+  readonly credential: string;
+  readonly kind: typeof CredentialKind.Type;
+  readonly target: CredentialTarget;
+  readonly roles: ReadonlyArray<typeof CredentialFieldRole.Type>;
+}
+declare const BrowserCredentialAccess_base: Context.ServiceClass<BrowserCredentialAccess, "@effect-agent/platform-cloudflare/BrowserCredentialAccess", {
+  readonly authorize: (request: CredentialAccessRequest) => Effect.Effect<void, CredentialAccessError>;
+  readonly resolve: (request: CredentialAccessRequest) => Effect.Effect<BrowserCredentialMaterial, CredentialAccessError>;
+}>;
+/**
+ * Invocation-owned authority. Derive caller/ownership from the host, not the public credential
+ * identifier. Authorize the actual merchant, frame, recipient, roles, and side effects of filling.
+ * Repeated checks must consult current grants. Never log or trace resolved material.
+ * Bind caller identity and identifier-to-vault-item selection for the whole invocation; an alias
+ * changing between resolve and authorize must never authorize different material.
+ */
+export declare class BrowserCredentialAccess extends BrowserCredentialAccess_base {}
+export declare const CredentialDispatch: Schema.Literals<readonly ["not-dispatched", "possibly-dispatched", "dispatched"]>;
+declare const CredentialFillResult_base: Schema.Class<CredentialFillResult, Schema.Struct<{
+  readonly dispatch: Schema.Literal<"dispatched">;
+  readonly filled: Schema.Natural;
+}>, {}>;
+/** Filled counts acknowledged assignments, not authentication, submission, or website acceptance. */
+export declare class CredentialFillResult extends CredentialFillResult_base {}
+declare const CredentialFillError_base: Schema.Class<CredentialFillError, Schema.TaggedStruct<"CredentialFillError", {
+  readonly reason: Schema.Literals<readonly ["denied", "missing-credential", "stale-target", "unsupported", "needs-attention", "busy", "provider", "resolver", "timeout"]>;
+  readonly dispatch: Schema.Literals<readonly ["not-dispatched", "possibly-dispatched", "dispatched"]>;
+  readonly filled: Schema.Natural;
+  readonly cleanup: Schema.Literals<readonly ["not-requested", "confirmed", "unconfirmed"]>;
+}>, import("effect/Cause").YieldableError>;
+/** Content-free evidence. A lost reply never authorizes a retry or proves that no write occurred. */
+export declare class CredentialFillError extends CredentialFillError_base {}
+//#endregion
+export { BrowserCredentials_d_exports as t };
+//# sourceMappingURL=BrowserCredentials.d.mts.map

package/dist/BrowserCredentials.mjs

@@ -0,0 +1,120 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Context, Schema } from "effect";
+//#region src/BrowserCredentials.ts
+var BrowserCredentials_exports = /* @__PURE__ */ __exportAll({
+	BrowserCredentialAccess: () => BrowserCredentialAccess,
+	BrowserCredentialMaterial: () => BrowserCredentialMaterial,
+	CardCredential: () => CardCredential,
+	CredentialAccessError: () => CredentialAccessError,
+	CredentialDispatch: () => CredentialDispatch,
+	CredentialFieldRole: () => CredentialFieldRole,
+	CredentialFillError: () => CredentialFillError,
+	CredentialFillResult: () => CredentialFillResult,
+	CredentialKind: () => CredentialKind,
+	CredentialOrigin: () => CredentialOrigin,
+	CredentialTarget: () => CredentialTarget,
+	FillCredentialRequest: () => FillCredentialRequest,
+	LoginCredential: () => LoginCredential
+});
+const Selector = Schema.NonEmptyString.check(Schema.isMaxLength(2048));
+const CredentialKind = Schema.Literals(["login", "card"]);
+const CredentialFieldRole = Schema.Literals([
+	"username",
+	"password",
+	"card-name",
+	"card-number",
+	"card-expiry",
+	"card-expiry-month",
+	"card-expiry-year",
+	"card-security-code"
+]);
+/** Canonical HTTPS origins, including non-default ports. Grants must match exactly. */
+const CredentialOrigin = Schema.String.check(Schema.isMaxLength(2048), Schema.makeFilter((value) => {
+	try {
+		const url = new URL(value);
+		return url.protocol === "https:" && url.origin === value && !url.username && !url.password;
+	} catch {
+		return false;
+	}
+}));
+var CredentialTarget = class extends Schema.Class("CredentialTarget")({
+	topOrigin: CredentialOrigin,
+	frameOrigin: CredentialOrigin,
+	recipientOrigin: CredentialOrigin
+}) {};
+/** Selectors identify one native form. Roles explicitly select material; no field inference occurs. */
+var FillCredentialRequest = class extends Schema.Class("FillCredentialRequest")({
+	credential: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
+	kind: CredentialKind,
+	frame: Schema.optionalKey(Schema.Array(Selector).check(Schema.isMaxLength(8))),
+	fields: Schema.Array(Schema.Struct({
+		selector: Selector,
+		role: CredentialFieldRole
+	})).check(Schema.isMinLength(1), Schema.isMaxLength(8))
+}) {};
+const SecretText = Schema.Redacted(Schema.NonEmptyString.check(Schema.isMaxLength(1024)));
+/** Host-only material. Never return or encode it through a Tool, log, trace, or checkpoint. */
+const LoginCredential = Schema.TaggedStruct("LoginCredential", {
+	username: SecretText,
+	password: SecretText
+});
+/** Security codes are transient; the host must not persist them. */
+const CardCredential = Schema.TaggedStruct("CardCredential", {
+	name: SecretText,
+	number: Schema.Redacted(Schema.String.check(Schema.isPattern(/^\d{12,19}$/))),
+	expiry: SecretText,
+	expiryMonth: Schema.Redacted(Schema.String.check(Schema.isPattern(/^(0[1-9]|1[0-2])$/))),
+	expiryYear: Schema.Redacted(Schema.String.check(Schema.isPattern(/^\d{4}$/))),
+	securityCode: Schema.optionalKey(Schema.Redacted(Schema.String.check(Schema.isPattern(/^\d{3,4}$/))))
+});
+const BrowserCredentialMaterial = Schema.Union([LoginCredential, CardCredential]);
+var CredentialAccessError = class extends Schema.TaggedError()("CredentialAccessError", { reason: Schema.Literals([
+	"denied",
+	"missing-credential",
+	"needs-attention",
+	"busy",
+	"resolver"
+]) }) {};
+/**
+* Invocation-owned authority. Derive caller/ownership from the host, not the public credential
+* identifier. Authorize the actual merchant, frame, recipient, roles, and side effects of filling.
+* Repeated checks must consult current grants. Never log or trace resolved material.
+* Bind caller identity and identifier-to-vault-item selection for the whole invocation; an alias
+* changing between resolve and authorize must never authorize different material.
+*/
+var BrowserCredentialAccess = class extends Context.Service()("@effect-agent/platform-cloudflare/BrowserCredentialAccess") {};
+const CredentialDispatch = Schema.Literals([
+	"not-dispatched",
+	"possibly-dispatched",
+	"dispatched"
+]);
+/** Filled counts acknowledged assignments, not authentication, submission, or website acceptance. */
+var CredentialFillResult = class extends Schema.Class("CredentialFillResult")({
+	dispatch: Schema.Literal("dispatched"),
+	filled: Schema.Natural.check(Schema.isLessThanOrEqualTo(8))
+}) {};
+/** Content-free evidence. A lost reply never authorizes a retry or proves that no write occurred. */
+var CredentialFillError = class extends Schema.TaggedError()("CredentialFillError", {
+	reason: Schema.Literals([
+		"denied",
+		"missing-credential",
+		"stale-target",
+		"unsupported",
+		"needs-attention",
+		"busy",
+		"provider",
+		"resolver",
+		"timeout"
+	]),
+	dispatch: CredentialDispatch,
+	filled: Schema.Natural.check(Schema.isLessThanOrEqualTo(8)),
+	cleanup: Schema.Literals([
+		"not-requested",
+		"confirmed",
+		"unconfirmed"
+	])
+}) {};
+//#endregion
+export { BrowserCredentialAccess, BrowserCredentialMaterial, CardCredential, CredentialAccessError, CredentialDispatch, CredentialFieldRole, CredentialFillError, CredentialFillResult, CredentialKind, CredentialOrigin, CredentialTarget, FillCredentialRequest, LoginCredential, BrowserCredentials_exports as t };
+
+//# sourceMappingURL=BrowserCredentials.mjs.map

package/dist/BrowserCredentials.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BrowserCredentials.mjs","names":[],"sources":["../src/BrowserCredentials.ts"],"sourcesContent":["import { Context, type Effect, Schema } from \"effect\";\n\nconst Selector = Schema.NonEmptyString.check(Schema.isMaxLength(2048));\n\nexport const CredentialKind = Schema.Literals([\"login\", \"card\"]);\n\nexport const CredentialFieldRole = Schema.Literals([\n  \"username\",\n  \"password\",\n  \"card-name\",\n  \"card-number\",\n  \"card-expiry\",\n  \"card-expiry-month\",\n  \"card-expiry-year\",\n  \"card-security-code\",\n]);\n\n/** Canonical HTTPS origins, including non-default ports. Grants must match exactly. */\nexport const CredentialOrigin = Schema.String.check(\n  Schema.isMaxLength(2048),\n  Schema.makeFilter((value) => {\n    try {\n      const url = new URL(value);\n\n      return url.protocol === \"https:\" && url.origin === value && !url.username && !url.password;\n    } catch {\n      return false;\n    }\n  }),\n);\n\nexport class CredentialTarget extends Schema.Class<CredentialTarget>(\"CredentialTarget\")({\n  topOrigin: CredentialOrigin,\n  frameOrigin: CredentialOrigin,\n  recipientOrigin: CredentialOrigin,\n}) {}\n\n/** Selectors identify one native form. Roles explicitly select material; no field inference occurs. */\nexport class FillCredentialRequest extends Schema.Class<FillCredentialRequest>(\n  \"FillCredentialRequest\",\n)({\n  credential: Schema.NonEmptyString.check(Schema.isMaxLength(256)),\n  kind: CredentialKind,\n  frame: Schema.optionalKey(Schema.Array(Selector).check(Schema.isMaxLength(8))),\n  fields: Schema.Array(Schema.Struct({ selector: Selector, role: CredentialFieldRole })).check(\n    Schema.isMinLength(1),\n    Schema.isMaxLength(8),\n  ),\n}) {}\n\nconst SecretText = Schema.Redacted(Schema.NonEmptyString.check(Schema.isMaxLength(1024)));\n\n/** Host-only material. Never return or encode it through a Tool, log, trace, or checkpoint. */\nexport const LoginCredential = Schema.TaggedStruct(\"LoginCredential\", {\n  username: SecretText,\n  password: SecretText,\n});\n\n/** Security codes are transient; the host must not persist them. */\nexport const CardCredential = Schema.TaggedStruct(\"CardCredential\", {\n  name: SecretText,\n  number: Schema.Redacted(Schema.String.check(Schema.isPattern(/^\\d{12,19}$/))),\n  expiry: SecretText,\n  expiryMonth: Schema.Redacted(Schema.String.check(Schema.isPattern(/^(0[1-9]|1[0-2])$/))),\n  expiryYear: Schema.Redacted(Schema.String.check(Schema.isPattern(/^\\d{4}$/))),\n  securityCode: Schema.optionalKey(\n    Schema.Redacted(Schema.String.check(Schema.isPattern(/^\\d{3,4}$/))),\n  ),\n});\n\nexport const BrowserCredentialMaterial = Schema.Union([LoginCredential, CardCredential]);\nexport type BrowserCredentialMaterial = typeof BrowserCredentialMaterial.Type;\n\nexport class CredentialAccessError extends Schema.TaggedError<CredentialAccessError>()(\n  \"CredentialAccessError\",\n  {\n    reason: Schema.Literals([\n      \"denied\",\n      \"missing-credential\",\n      \"needs-attention\",\n      \"busy\",\n      \"resolver\",\n    ]),\n  },\n) {}\n\nexport interface CredentialAccessRequest {\n  readonly credential: string;\n  readonly kind: typeof CredentialKind.Type;\n  readonly target: CredentialTarget;\n  readonly roles: ReadonlyArray<typeof CredentialFieldRole.Type>;\n}\n\n/**\n * Invocation-owned authority. Derive caller/ownership from the host, not the public credential\n * identifier. Authorize the actual merchant, frame, recipient, roles, and side effects of filling.\n * Repeated checks must consult current grants. Never log or trace resolved material.\n * Bind caller identity and identifier-to-vault-item selection for the whole invocation; an alias\n * changing between resolve and authorize must never authorize different material.\n */\nexport class BrowserCredentialAccess extends Context.Service<\n  BrowserCredentialAccess,\n  {\n    readonly authorize: (\n      request: CredentialAccessRequest,\n    ) => Effect.Effect<void, CredentialAccessError>;\n    readonly resolve: (\n      request: CredentialAccessRequest,\n    ) => Effect.Effect<BrowserCredentialMaterial, CredentialAccessError>;\n  }\n>()(\"@effect-agent/platform-cloudflare/BrowserCredentialAccess\") {}\n\nexport const CredentialDispatch = Schema.Literals([\n  \"not-dispatched\",\n  \"possibly-dispatched\",\n  \"dispatched\",\n]);\n\n/** Filled counts acknowledged assignments, not authentication, submission, or website acceptance. */\nexport class CredentialFillResult extends Schema.Class<CredentialFillResult>(\n  \"CredentialFillResult\",\n)({\n  dispatch: Schema.Literal(\"dispatched\"),\n  filled: Schema.Natural.check(Schema.isLessThanOrEqualTo(8)),\n}) {}\n\n/** Content-free evidence. A lost reply never authorizes a retry or proves that no write occurred. */\nexport class CredentialFillError extends Schema.TaggedError<CredentialFillError>()(\n  \"CredentialFillError\",\n  {\n    reason: Schema.Literals([\n      \"denied\",\n      \"missing-credential\",\n      \"stale-target\",\n      \"unsupported\",\n      \"needs-attention\",\n      \"busy\",\n      \"provider\",\n      \"resolver\",\n      \"timeout\",\n    ]),\n    dispatch: CredentialDispatch,\n    filled: Schema.Natural.check(Schema.isLessThanOrEqualTo(8)),\n    cleanup: Schema.Literals([\"not-requested\", \"confirmed\", \"unconfirmed\"]),\n  },\n) {}\n"],"mappings":"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"}

package/dist/BrowserRestCapture.d.mts

@@ -0,0 +1,34 @@
+import { o as BrowserQuickActionWorkersAi, s as BrowserQuickActionWorkersAiPolicy } from "./CloudflareBrowser-gu7gma0Y.mjs";
+import { Layer, Redacted } from "effect";
+import { PageCapture } from "@yielded/agent/page-capture";
+import { SandboxImplementation } from "@yielded/agent/sandbox";
+import { HttpClient } from "effect/http";
+//#region src/BrowserRestCapture.d.ts
+/** Node-safe REST PageCapture implementation; it never imports Worker runtime modules. */
+export declare const browserRestCaptureImplementation: SandboxImplementation;
+/** Explicit construction inputs; credentials are only projected into the fixed-origin Authorization header. */
+export interface BrowserRestCaptureOptions {
+  readonly accountId: string;
+  readonly apiToken: Redacted.Redacted<string>;
+}
+/** REST PageCapture layer for Node and other non-Worker composition roots. */
+export declare const browserRestCaptureLayer: (options: BrowserRestCaptureOptions) => Layer.Layer<PageCapture, never, HttpClient.HttpClient>;
+/** REST structured extraction additionally requires explicit Workers AI authorization/accounting. */
+export declare const browserRestWorkersAiCaptureLayer: (options: BrowserRestCaptureOptions) => Layer.Layer<PageCapture, never, HttpClient.HttpClient | BrowserQuickActionWorkersAi>;
+/** Explicit REST credentials and optional authorization for separately billed extraction. */
+export interface CloudflareBrowserRestOptions extends BrowserRestCaptureOptions {
+  readonly workersAi?: BrowserQuickActionWorkersAiPolicy;
+}
+/** Node-safe WebCapture handler assembly; the application supplies its HttpClient. */
+export declare const CloudflareBrowserRest: {
+  /**
+   * Supports capture, scrape, and extraction definitions. Only PageCapture is supplied;
+   * handler errors and other services remain visible. Extraction fails closed without
+   * workersAi. Existing host policies, response limits, and scoped cleanup are unchanged.
+   */
+  layer: <A, E, R>(definition: {
+    readonly handlers: Layer.Layer<A, E, R>;
+  }, options: CloudflareBrowserRestOptions) => Layer.Layer<A, E, Exclude<R, PageCapture> | HttpClient.HttpClient>;
+};
+//#endregion
+//# sourceMappingURL=BrowserRestCapture.d.mts.map