iterate 0.3.0 → 0.4.0

package/dist/processors/processor-contracts.d.ts

@@ -1,342 +0,0 @@
-import { z } from "zod";
-import type { StreamEvent, StreamEventInput } from "./schemas.ts";
-/**
- * Merge one processor configuration patch into its current configuration.
- *
- * Configuration patches recurse only through plain JSON objects. Arrays,
- * scalars, and `null` replace the previous value wholesale; omitted keys are
- * retained. Processors validate the merged result with their own complete
- * configuration schema before storing it in reduced state.
- */
-export declare function mergeProcessorConfig(base: unknown, patch: unknown): unknown;
-/**
- * One documented example payload for an owned event, rendered on the public
- * event docs site (events.iterate.com). The payload must parse against the
- * event's `payloadSchema` — enforced by the event-docs unit tests rather than
- * at module load, so a bad example fails CI instead of bricking a worker boot.
- */
-export type EventExample = {
-    /** What this example shows, e.g. "Durable delivery to another stream". */
-    description: string;
-    /** The example payload, in the payload schema's input shape. */
-    payload: unknown;
-};
-/** One owned event: its payload schema plus optional human description and examples. */
-export type EventDefinition<PayloadOutput = unknown, PayloadInput = PayloadOutput> = {
-    description?: string;
-    payloadSchema: z.ZodType<PayloadOutput, PayloadInput>;
-    /**
-     * FORCIBLY ephemeral: every append and parse built from this definition
-     * defaults the envelope's `ephemeral` flag to `true` and REJECTS an explicit
-     * `ephemeral: false`. For events that must never become durable stream
-     * facts (streaming chunks) — declaring it here makes forgetting the flag at
-     * an append site impossible instead of a silent storage leak.
-     */
-    ephemeral?: true;
-    examples?: readonly EventExample[];
-};
-/** A contract's owned events, keyed by the durable event type string. */
-export type EventCatalog = Record<string, EventDefinition<unknown, unknown>>;
-/** The string-keyed event definitions of a catalog object (index signatures excluded). */
-type EventCatalogFromObject<Value> = {
-    [Key in keyof Value as string extends Key ? never : number extends Key ? never : Value[Key] extends EventDefinition ? Key : never]: Value[Key];
-};
-/**
- * A `processorDeps` entry may be a full contract (`{ events: ... }`) or a
- * standalone event catalog, so a processor can depend on another processor's
- * contract or on a small shared catalog.
- */
-type ContractEventCatalog<ContractOrCatalog> = ContractOrCatalog extends {
-    events: infer Events;
-} ? EventCatalogFromObject<Events> : EventCatalogFromObject<ContractOrCatalog>;
-/** All event type strings resolvable from local `events` plus `processorDeps`. */
-type ResolvedEventType<Events extends EventCatalog, ProcessorDeps extends readonly unknown[]> = Extract<keyof EventCatalogFromObject<Events> | EventTypeFromProcessorDeps<ProcessorDeps>, string>;
-/** Union of every event type string owned by any `processorDeps` entry. */
-type EventTypeFromProcessorDeps<ProcessorDeps extends readonly unknown[]> = ProcessorDeps[number] extends infer ProcessorDep ? ProcessorDep extends unknown ? keyof ContractEventCatalog<ProcessorDep> : never : never;
-/**
- * Resolve a string event type to the definition that owns it. Local events win
- * in the type-level lookup; runtime validation rejects duplicate ownership.
- */
-type EventDefinitionForType<Events extends EventCatalog, ProcessorDeps extends readonly unknown[], Type extends string> = Type extends keyof Events ? Events[Type] : ProcessorDeps[number] extends infer ProcessorDep ? ProcessorDep extends unknown ? Type extends keyof ContractEventCatalog<ProcessorDep> ? ContractEventCatalog<ProcessorDep>[Type] : never : never : never;
-/** `StreamEventInput` with `type`/`payload` narrowed to one event definition. */
-type TypedStreamEventInput<Type extends string = string, Payload = Record<string, unknown>> = Omit<StreamEventInput, "payload" | "type"> & {
-    type: Type;
-    payload: Payload;
-};
-/**
- * A durable processor input. Wake processors never receive ephemeral events, so
- * a domain object's processor-typed append door must not claim that they do.
- */
-type TypedConsumedEventInput<Type extends string = string, Payload = Record<string, unknown>> = Omit<TypedStreamEventInput<Type, Payload>, "ephemeral"> & {
-    ephemeral?: never;
-};
-/** `StreamEvent` with `type`/`payload` narrowed to one event definition. */
-type TypedStreamEvent<Type extends string = string, Payload = Record<string, unknown>> = Omit<StreamEvent, "payload" | "type"> & TypedStreamEventInput<Type, Payload>;
-/** Committed event for one resolved type (payload parsed, so required). */
-type EventFromType<Events extends EventCatalog, ProcessorDeps extends readonly unknown[], Type extends string> = Type extends unknown ? EventDefinitionForType<Events, ProcessorDeps, Type> extends EventDefinition<infer PayloadOutput, unknown> ? TypedStreamEvent<Type, PayloadOutput> & {
-    payload: PayloadOutput;
-} & ParsedEphemeralEnvelope<EventDefinitionForType<Events, ProcessorDeps, Type>> : never : never;
-/** A committed event resolved from a contract's owned events or processor dependencies.
- * Unknown event-type strings retain the untyped {@link StreamEvent} shape. */
-export type ResolvedEvent<Contract, Type extends string> = Contract extends {
-    events: EventCatalog;
-} ? Type extends ResolvedEventType<ContractEventCatalog<Contract>, ProcessorDepsOf<Contract>> ? EventFromType<ContractEventCatalog<Contract>, ProcessorDepsOf<Contract>, Type> : StreamEvent : StreamEvent;
-/** Union of committed-event shapes for a `consumes` tuple; `"*"` alone means any `StreamEvent`. */
-type EventFromTypes<Events extends EventCatalog, ProcessorDeps extends readonly unknown[], Types extends readonly string[]> = "*" extends Types[number] ? [Exclude<Types[number], "*">] extends [never] ? StreamEvent : EventFromType<Events, ProcessorDeps, Exclude<Types[number], "*">> : EventFromType<Events, ProcessorDeps, Types[number]>;
-/** Append input for one resolved type (payload accepts the schema's input shape). */
-type InputFromType<Events extends EventCatalog, ProcessorDeps extends readonly unknown[], Type extends string> = Type extends unknown ? EventDefinitionForType<Events, ProcessorDeps, Type> extends EventDefinition<unknown, infer PayloadInput> ? TypedStreamEventInput<Type, PayloadInput> : never : never;
-/** Durable append input for one event delivered to a wake processor. */
-type ConsumedInputFromType<Events extends EventCatalog, ProcessorDeps extends readonly unknown[], Type extends string> = Type extends unknown ? EventDefinitionForType<Events, ProcessorDeps, Type> extends EventDefinition<unknown, infer PayloadInput> ? TypedConsumedEventInput<Type, PayloadInput> : never : never;
-/** Durable append-input shapes for a processor's `consumes` tuple. */
-type ConsumedInputFromTypes<Events extends EventCatalog, ProcessorDeps extends readonly unknown[], Types extends readonly string[]> = "*" extends Types[number] ? Omit<StreamEventInput, "ephemeral"> & {
-    ephemeral?: never;
-} : ConsumedInputFromType<Events, ProcessorDeps, Types[number]>;
-/** Parsed append input for one resolved type (payload validated, so required). */
-type ParsedInputFromType<Events extends EventCatalog, ProcessorDeps extends readonly unknown[], Type extends string> = Type extends unknown ? EventDefinitionForType<Events, ProcessorDeps, Type> extends EventDefinition<infer PayloadOutput, unknown> ? TypedStreamEventInput<Type, PayloadOutput> & {
-    payload: PayloadOutput;
-} & ParsedEphemeralEnvelope<EventDefinitionForType<Events, ProcessorDeps, Type>> : never : never;
-/** Contract-forced ephemeral inputs default to `true` during parsing. */
-type ParsedEphemeralEnvelope<Definition> = Definition extends {
-    ephemeral: true;
-} ? {
-    ephemeral: true;
-} : unknown;
-/** A typed builder preserves the supplied envelope while returning parsed payload/default output. */
-type BuiltInputFromEvent<Events extends EventCatalog, ProcessorDeps extends readonly unknown[], Event extends {
-    type: string;
-}> = Event extends unknown ? Omit<Event, "payload"> & Pick<ParsedInputFromType<Events, ProcessorDeps, Event["type"]>, "payload"> & ParsedEphemeralEnvelope<EventDefinitionForType<Events, ProcessorDeps, Event["type"]>> : never;
-/** Parsed durable inputs for a processor's `consumes` tuple. */
-type ParsedConsumedInputFromTypes<Events extends EventCatalog, ProcessorDeps extends readonly unknown[], Types extends readonly string[]> = "*" extends Types[number] ? Omit<StreamEventInput, "ephemeral"> & {
-    ephemeral?: never;
-} : Types[number] extends infer Type extends string ? EventDefinitionForType<Events, ProcessorDeps, Type> extends EventDefinition<infer PayloadOutput, unknown> ? TypedConsumedEventInput<Type, PayloadOutput> : never : never;
-/** Union of committed-event shapes a contract's `consumes` list can deliver to `reduce`. */
-export type ConsumedEvent<Contract> = Contract extends {
-    events: EventCatalog;
-    consumes: infer Consumes extends readonly string[];
-} ? EventFromTypes<ContractEventCatalog<Contract>, ProcessorDepsOf<Contract>, Consumes> : never;
-/**
- * Union of durable append-input shapes accepted by a contract's `consumes`
- * list. Ephemeral events are excluded because hosted processors cannot consume
- * them; append those intentionally through the raw Stream door. This is a
- * schema/vocabulary union, not proof that an event is valid in the processor's
- * current state or came from a particular provenance.
- */
-export type ConsumedInput<Contract> = Contract extends {
-    events: EventCatalog;
-    consumes: infer Consumes extends readonly string[];
-} ? ConsumedInputFromTypes<ContractEventCatalog<Contract>, ProcessorDepsOf<Contract>, Consumes> : never;
-/** Union of append-input shapes a contract's `emits` list allows a processor to append. */
-export type EmittedInput<Contract> = Contract extends {
-    events: EventCatalog;
-    emits: infer Emits extends readonly string[];
-} ? InputFromType<ContractEventCatalog<Contract>, ProcessorDepsOf<Contract>, Emits[number]> : never;
-/** A contract's `processorDeps` tuple, defaulting to empty when absent. */
-type ProcessorDepsOf<Contract> = Contract extends {
-    processorDeps?: infer ProcessorDeps;
-} ? ProcessorDeps extends readonly unknown[] ? ProcessorDeps : readonly [] : readonly [];
-/** A contract's reduced-state type, inferred from its `stateSchema`. */
-export type ProcessorState<Contract> = Contract extends {
-    stateSchema: infer State extends z.ZodType;
-} ? z.output<State> : never;
-/** Reduced state must be object-shaped and must accept `{}` (the empty initial state). */
-type DefaultableObjectStateSchema<StateSchema extends z.ZodType> = z.output<StateSchema> extends Record<string, unknown> ? {} extends z.input<StateSchema> ? StateSchema : never : never;
-/**
- * Compile-time typo guard for `consumes` / `emits`: resolves to `unknown` when
- * every string in `Types` is resolvable (leaving the contract argument
- * unchanged), `never` when one is not — failing the call where the bad string
- * is written. `AllowStar` admits the `"*"` wildcard (consumes only).
- */
-type ResolvedEventTypesOnly<Events extends EventCatalog, ProcessorDeps extends readonly unknown[], Types extends readonly string[], AllowStar extends string = never> = [Exclude<Exclude<Types[number], AllowStar>, ResolvedEventType<Events, ProcessorDeps>>] extends [
-    never
-] ? unknown : never;
-/** `contract.buildEvent(...)`: validate an append input against the resolved payload schema. */
-type ProcessorContractBuildEvent<Events extends EventCatalog, ProcessorDeps extends readonly unknown[]> = <const Event extends InputFromType<Events, ProcessorDeps, ResolvedEventType<Events, ProcessorDeps>> & {
-    type: string;
-}>(event: Event) => BuiltInputFromEvent<Events, ProcessorDeps, Event>;
-/** Resolved contract types compatible with an event's current discriminator type. */
-type ResolvedTypeFromEvent<Events extends EventCatalog, ProcessorDeps extends readonly unknown[], Event extends {
-    type: string;
-}> = Extract<ResolvedEventType<Events, ProcessorDeps>, Event["type"]>;
-/** `contract.parseEvent(...)`: validate a committed event and infer its output from `event.type`. */
-type ProcessorContractParseEvent<Events extends EventCatalog, ProcessorDeps extends readonly unknown[]> = <const Event extends StreamEvent>(event: Event) => EventFromType<Events, ProcessorDeps, ResolvedTypeFromEvent<Events, ProcessorDeps, Event>>;
-/**
- * Same as `parseEvent`, but for append inputs that do not yet have an offset or
- * createdAt. This exists for stream-owned pre-commit policy: the Stream Durable
- * Object must reject some contract-owned events BEFORE they become durable
- * facts (see the core processor's `validate`) — validating them
- * later, in the wake side effect, would leave the invalid event committed and
- * reduced into durable state. The lifecycle e2e tests assert both the rejection
- * and that nothing was committed.
- */
-type ProcessorContractParseEventInput<Events extends EventCatalog, ProcessorDeps extends readonly unknown[]> = <const Event extends StreamEventInput>(event: Event) => ParsedInputFromType<Events, ProcessorDeps, ResolvedTypeFromEvent<Events, ProcessorDeps, Event>>;
-/**
- * `contract.parseConsumedInput(...)`: validate one domain-object append
- * against the exact event vocabulary delivered to the processor.
- */
-type ProcessorContractParseConsumedInput<Events extends EventCatalog, ProcessorDeps extends readonly unknown[], Consumes extends readonly string[]> = <const Event extends ConsumedInputFromTypes<Events, ProcessorDeps, Consumes>>(event: Event) => "*" extends Consumes[number] ? ParsedConsumedInputFromTypes<Events, ProcessorDeps, Consumes> : ParsedConsumedInputFromTypes<Events, ProcessorDeps, readonly Extract<Consumes[number], Event["type"]>[]>;
-/**
- * `getEventSchema` without offset/createdAt (and strict, so an accidental
- * `offset` key on an append input fails loudly). Gives pre-append policy code
- * the same payload validation as reducers, without fabricating a committed
- * event just to get at the typed payload.
- */
-export declare function getEventInputSchema<const Type extends string, const PayloadSchema extends z.ZodType>(args: {
-    type: Type;
-    payloadSchema: PayloadSchema;
-    ephemeral?: boolean;
-}): z.ZodType<TypedStreamEventInput<Type, z.output<PayloadSchema>>, TypedStreamEventInput<Type, z.input<PayloadSchema>>>;
-/** Memoized {@link getEventSchema} (see {@link eventSchemaCache}). */
-export declare function cachedEventSchema(args: {
-    type: string;
-    payloadSchema: z.ZodType;
-    ephemeral?: boolean;
-}): z.ZodType;
-/** Union of append-input shapes for every event a contract can resolve (own + deps). */
-type ResolvedEventInput<Contract> = Contract extends {
-    events: EventCatalog;
-} ? InputFromType<ContractEventCatalog<Contract>, ProcessorDepsOf<Contract>, ResolvedEventType<ContractEventCatalog<Contract>, ProcessorDepsOf<Contract>>> : never;
-/**
- * Validate an append input with the payload schema resolved from a processor
- * contract. Prefer the contract-bound `contract.buildEvent(event)` API, which
- * carries the same types without repeating the contract in the argument.
- *
- * @deprecated Use `contract.buildEvent(event)`.
- */
-export declare function buildEvent<const Contract extends {
-    slug?: string;
-    events: EventCatalog;
-    processorDeps?: readonly unknown[];
-}, const Event extends ResolvedEventInput<NoInfer<Contract>> & {
-    type: string;
-}>(args: {
-    contract: Contract;
-    event: Event;
-}): BuiltInputFromEvent<ContractEventCatalog<Contract>, ProcessorDepsOf<Contract>, Event>;
-/**
- * Typed identity for processor contracts: validation plus the pre-bound
- * `buildEvent` / `parseEvent` / `parseEventInput` / `parseConsumedInput`
- * helpers.
- *
- * The signature enforces the important invariants at authoring time:
- *
- * - `stateSchema` must parse `{}` to an object-shaped reduced state;
- * - every string in `consumes` and `emits` must resolve against local `events`
- *   plus `processorDeps` (and both are contextually typed for autocomplete);
- * - local `events` must not redefine an event already owned by a
- *   `processorDeps` contract. Event ownership is intentionally one processor
- *   deep: a processor can depend on another owner, but it cannot shadow that
- *   owner's public event type with a second payload schema.
- */
-export declare function defineProcessorContract<const StateSchema extends z.ZodType, const Events extends EventCatalog, const Consumes extends readonly (ResolvedEventType<Events, ProcessorDeps> | "*")[], const Emits extends readonly ResolvedEventType<Events, ProcessorDeps>[], const ProcessorDeps extends readonly unknown[] = readonly []>(contract: {
-    slug: string;
-    version: string;
-    description: string;
-    stateSchema: DefaultableObjectStateSchema<StateSchema>;
-    processorDeps?: ProcessorDeps;
-    events: Events;
-    consumes: Consumes & ResolvedEventTypesOnly<Events, ProcessorDeps, Consumes, "*">;
-    emits: Emits & ResolvedEventTypesOnly<Events, ProcessorDeps, Emits>;
-}): {
-    slug: string;
-    version: string;
-    description: string;
-    stateSchema: StateSchema;
-    processorDeps?: ProcessorDeps;
-    events: Events;
-    consumes: Consumes;
-    emits: Emits;
-    buildEvent: ProcessorContractBuildEvent<Events, ProcessorDeps>;
-    parseEvent: ProcessorContractParseEvent<Events, ProcessorDeps>;
-    parseEventInput: ProcessorContractParseEventInput<Events, ProcessorDeps>;
-    parseConsumedInput: ProcessorContractParseConsumedInput<Events, ProcessorDeps, Consumes>;
-};
-/**
- * Enforces the invariant that reduced processor state is object-shaped (so
- * state slices can evolve safely and hooks never branch on primitive state).
- */
-export declare function assertObjectProcessorState(args: {
-    processorSlug: string;
-    value: unknown;
-}): void;
-/**
- * Resolve the payload schema a processor should use for an incoming event:
- * the named definition when the type is listed in `consumes`, a permissive
- * `z.unknown()` definition when the contract consumes `"*"`, and `undefined`
- * when the event is not consumed at all. Runtime counterpart of
- * `ConsumedEvent<Contract>`.
- *
- * `"*"` NEVER MATCHES AN EPHEMERAL EVENT, and that one rule is what lets
- * ephemeral types live in `consumes` beside durable ones instead of in a
- * parallel list. Naming a type explicitly is the opt-in: you cannot be handed
- * a microphone firehose by a wildcard you wrote for durable facts, and a
- * processor that wants live events says so by type. Ephemeral bodies live
- * only in the Stream DO's bounded buffer, so a processor receiving one must
- * have decided it can cope with never seeing it again — a decision nobody
- * makes by writing `"*"`.
- */
-export declare function getConsumedEventDefinition(args: {
-    contract: {
-        events: EventCatalog;
-        processorDeps?: readonly unknown[];
-        consumes: readonly string[];
-    };
-    eventType: string;
-    /** Whether the event being resolved is ephemeral; gates the `"*"` fallback. */
-    ephemeral?: boolean;
-}): EventDefinition | undefined;
-export declare function getResolvedEventDefinition(args: {
-    contract: {
-        events: EventCatalog;
-        processorDeps?: readonly unknown[];
-    };
-    eventType: string;
-}): EventDefinition | undefined;
-/**
- * The ONE platform revival fact for every recovery-wired stream processor.
- * Appended by the platform keepalive (`durableObjectRecovery` in
- * durable-object-processor-durability.ts) when a processor is revived after
- * its incarnation died owing background work — never emitted by a processor.
- * Per-processor identity rides the payload's `processorSlug` and the
- * `processor-revived:<slug>@...` idempotency key, not the type string.
- * Consuming it is OPTIONAL: a processor should do so only when it reacts to
- * the fact itself. Its append still wakes delivery when it is unconsumed, and
- * a head-reaching frame receives the runner's eventless
- * `processEvent(event: null, caughtUp: true)` pass so open obligations are not
- * stranded. The event DEFINITION (payload schema) lives with the platform's
- * core stream contract; this constant is here so contracts and the recovery
- * adapter agree on the type string without importing that contract.
- */
-export declare const STREAM_PROCESSOR_REVIVED_EVENT_TYPE = "events.iterate.com/stream/processor-revived";
-/**
- * A processor contract announcement carried on `connection-opened` when the
- * callback owner is a hosted stream processor. UIs and tooling read it from
- * that event and from `runtime.connections[..].openedBy`.
- */
-export declare const ProcessorContractAnnouncement: z.ZodObject<{
-    slug: z.ZodString;
-    version: z.ZodString;
-    description: z.ZodString;
-    consumes: z.ZodArray<z.ZodString>;
-    emits: z.ZodArray<z.ZodString>;
-    ownedEvents: z.ZodArray<z.ZodObject<{
-        type: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type ProcessorContractAnnouncement = z.infer<typeof ProcessorContractAnnouncement>;
-/**
- * Platform stream events a processor contract may CONSUME without owning —
- * pass as a `processorDeps` entry. Currently just the keepalive revival fact.
- * Consumption is optional and belongs only in processors that react to the
- * fact itself; an unconsumed revival tail receives the runner's eventless
- * at-head turn. The event's authoritative definition lives with the
- * platform's core stream contract, and this catalog is deliberately
- * payload-loose.
- */
-export declare const PLATFORM_STREAM_EVENTS: {
-    "events.iterate.com/stream/processor-revived": {
-        description: string;
-        payloadSchema: z.ZodObject<{}, z.core.$loose>;
-    };
-};
-export {};

package/dist/processors/processor-facet.d.ts

@@ -1,186 +0,0 @@
-import { DurableObject } from "cloudflare:workers";
-import type { LiveStateCursor } from "../sdk/capnweb/live-state/protocol.ts";
-import type { LiveStateRpc } from "../sdk/capnweb/live-state/types.ts";
-import type { ProcessorStream } from "./stream-handle.ts";
-import type { MaybePromise } from "./stream-processor.ts";
-import type { ProcessorRuntimeState, ProcessorSnapshot, StreamProcessorWakeRequest, StreamProcessorWakeResponse } from "./rpc-types.ts";
-import { type StreamProcessorRegistry } from "./stream-processor-registry.ts";
-/**
- * Where the configured identity lives in the facet's own kv. Exported so a
- * subclass's own doors can self-heal a fresh incarnation (re-run the
- * idempotent `configure` from the stash) before the base's boot microtask has
- * run — see apps/os `ProcessorFacet.#requireRegistry`.
- */
-export declare const FACET_IDENTITY_KEY = "iterate:processor-facet:identity";
-/**
- * The identity a {@link ProcessorFacet} is configured with on first contact —
- * stashed durably in the facet's own kv, never passed again. `path` +
- * `projectId` are the registry's wake coordinate fence; `parentName` is how
- * the facet dials BACK to the Durable Object hosting it (the Stream DO) for
- * the alarm proxy.
- */
-export type ProcessorFacetIdentity = {
-    /** Durable Object name of the hosting parent (the Stream DO). */
-    parentName: string;
-    /** Owning project of the hosted stream, or null on a deployment-global stream. */
-    projectId: string | null;
-    /** Path of the hosted stream. */
-    path: string;
-};
-/**
- * The three parent-side alarm doors a facet dials in place of its own
- * (unimplemented) `ctx.storage` alarm verbs. The parent implements them over
- * its REAL platform alarm and replays each fire into the facet's
- * {@link ProcessorFacet.handleAlarm}. The parent's implementations MUST
- * tolerate being called reentrantly while the parent itself is still awaiting
- * `handleAlarm` — the keepalive re-arms from inside its own alarm turn.
- */
-export type ProcessorFacetAlarmProxy = {
-    proxySetAlarm(scheduledTimeMs: number): MaybePromise<unknown>;
-    proxyDeleteAlarm(): MaybePromise<unknown>;
-    proxyGetAlarm(): MaybePromise<number | null>;
-};
-/**
- * Everything app-specific about one facet host, derived from the stashed
- * identity by {@link ProcessorFacet.createHost}: the stream handle processors
- * append through, the worker deploy version (keepalive crash-loop budget
- * reset), and the per-host processor composition — the subclass constructs its
- * processors here and registers each under its subscription name.
- */
-export type ProcessorFacetHost = {
-    /** The hosted stream — how processors append/read (colocated: a dial back
-     * to the parent Stream DO's stream surface). */
-    stream: ProcessorStream;
-    /** Worker deploy version — pass this worker's build identity. A change
-     * resets each keepalive's crash-loop budget (the antidote deploy). */
-    version: string;
-    /** Injected clock for tests; production omits it (Date.now). */
-    now?: () => number;
-    /** Assemble this node's live state; omit for the primary runner's fold. */
-    getLiveState?: () => Record<string, unknown>;
-    /** Construct and register this host's processors (`registry.register(new
-     * XProcessor({...}), { recovery, name })`) — called once, right after the
-     * registry is built. Per-processor recovery stays the author's explicit
-     * choice, exactly as on a hosting DO. */
-    registerProcessors(registry: StreamProcessorRegistry): void;
-};
-/**
- * A facet's `DurableObjectState` facade for `createStreamProcessorRegistry`:
- * ONLY `storage.setAlarm` / `storage.deleteAlarm` / `storage.getAlarm` are
- * overridden to dial the parent's {@link ProcessorFacetAlarmProxy}; kv,
- * waitUntil, and everything else pass through untouched. `parentAlarms` is
- * invoked PER CALL — the parent stub must be resolved lazily from the stashed
- * identity, because the recovery adapter's boot reconcile issues alarm calls
- * at construction and a stub captured once would outlive its RPC session.
- */
-export declare function facetProcessorDurableObjectState(ctx: DurableObjectState, parentAlarms: () => ProcessorFacetAlarmProxy): DurableObjectState;
-/**
- * Plain-copy an `AlarmInvocationInfo` before a facet hop. The platform hands
- * the parent's `alarm()` a host object that does not serialize across RPC;
- * a parent replaying a fire into {@link ProcessorFacet.handleAlarm} must send
- * this copy instead.
- */
-export declare function plainAlarmInvocationInfo(info: AlarmInvocationInfo | undefined): AlarmInvocationInfo | undefined;
-/**
- * Generic base for hosting stream processors in a Durable Object facet.
- * Subclasses are the per-host composition (the facets task's target shape) and
- * supply exactly two things: how to dial the parent's alarm proxy and what
- * this host runs —
- *
- * ```ts
- * export class AgentProcessors extends ProcessorFacet<Env> {
- *   protected parentAlarms({ parentName }: ProcessorFacetIdentity) {
- *     return this.env.STREAM.getByName(parentName);
- *   }
- *   protected createHost({ path, projectId }: ProcessorFacetIdentity): ProcessorFacetHost {
- *     const stream = ...; // dial the parent stream
- *     return {
- *       stream,
- *       version: workerVersion(this.env),
- *       registerProcessors: (registry) => {
- *         registry.register(
- *           new AgentProcessor({ stream, path, projectId, ... }),
- *           { recovery: true, name: "agent" },
- *         );
- *       },
- *     };
- *   }
- * }
- * ```
- *
- * The parent creates it with `ctx.facets.get(name, () => ({ class:
- * ctx.exports.AgentProcessors }))`, calls `configure()` once (idempotent), and
- * routes wakes/alarms/doors to the RPC surface below.
- *
- * THIS CLASS MUST NEVER DEFINE `alarm()` — and neither may a subclass. The
- * fire arrives as `handleAlarm` (an ordinary RPC verb) instead: workerd
- * reserves `alarm` for its native handler, and with one present a failed
- * native `setAlarm` poisons the facet's output gate (workerd#6810). The
- * constructor enforces this.
- */
-export declare abstract class ProcessorFacet<Env = unknown> extends DurableObject<Env> {
-    #private;
-    constructor(ctx: DurableObjectState, env: Env);
-    /**
-     * Resolve the parent's alarm-proxy stub for the stashed identity — e.g.
-     * `this.env.STREAM.getByName(identity.parentName)`. Called once per alarm
-     * verb invocation (stubs must not outlive their call turn).
-     */
-    protected abstract parentAlarms(identity: ProcessorFacetIdentity): ProcessorFacetAlarmProxy;
-    /** Build this host's app-specific wiring from the stashed identity — called
-     * once per incarnation, lazily on first use. */
-    protected abstract createHost(identity: ProcessorFacetIdentity): ProcessorFacetHost;
-    /**
-     * First-contact identity stash, idempotent: re-configuring with the same
-     * identity is a no-op (and ensures the host is built); a DIFFERENT identity
-     * throws — a facet's coordinate never changes, so a mismatch is a miswire,
-     * not a migration.
-     */
-    configure(identity: ProcessorFacetIdentity): void;
-    /** The wake door — the parent's colocated delivery dial. Routes to the
-     * registry: name-first resolution, coordinate fence, per-batch settlement
-     * through each batch's independent `reportDeliveryResult`. */
-    wakeStreamProcessor(request: StreamProcessorWakeRequest): Promise<StreamProcessorWakeResponse>;
-    /**
-     * The parent's alarm replay door — deliberately NOT named `alarm` (see the
-     * class doc). The parent plain-copies its `AlarmInvocationInfo`
-     * ({@link plainAlarmInvocationInfo}) and awaits this; a rejection propagates
-     * so the parent can rethrow and get the platform's alarm retry.
-     */
-    handleAlarm(info?: AlarmInvocationInfo): Promise<void>;
-    /** One consistent read of a hosted processor's committed fold. `name` may be
-     * omitted on a single-processor host. */
-    snapshot(args?: {
-        name?: string;
-    }): Promise<ProcessorSnapshot<unknown>>;
-    /** The hosted processor's runtime state (runner snapshot + contributed
-     * runtime bag). `name` may be omitted on a single-processor host. */
-    getRuntimeState(args?: {
-        name?: string;
-    }): Promise<ProcessorRuntimeState>;
-    /** Resolve once the named processor's acknowledged cursor reaches `offset` —
-     * the read-your-writes barrier. The subscription catalog's uniform
-     * `waitUntilProcessed` delegates its facet-placed processor rows here. */
-    waitUntilProcessed(args: {
-        offset: number;
-        timeoutMs?: number;
-        name?: string;
-    }): Promise<void>;
-    /** Pull the named processor through the durable stream tail — the parent
-     * facade's catch-up-before-snapshot leg, dialed before every facet read.
-     * `name` may be omitted on a single-processor host. */
-    catchUp(args?: {
-        name?: string;
-    }): Promise<void>;
-    /** Read a transient snapshot or delta for the parent's current stream lifetime.
-     * Cold or replaced processors hydrate from durable progress. Warm reads use
-     * committed local state: polling must not call back into the parent stream
-     * for every processor while it is delivering events to this facet. */
-    readLiveState(args: {
-        streamId: string;
-        cursor?: LiveStateCursor;
-        patchVersion?: 2 | 3;
-    }): Promise<import("../sdk/capnweb/index.ts").LiveStateRead<Record<string, unknown>>>;
-    /** Direct subscriptions retain their callbacks across the Workers RPC hop. */
-    liveState(): LiveStateRpc<Record<string, unknown>>;
-}

package/dist/processors/processor-host-capabilities.d.ts

@@ -1,60 +0,0 @@
-import type { z } from "zod";
-import type { GetProcessorRuntimeState, ProcessorSnapshot, StreamConnectionPing } from "./rpc-types.ts";
-import type { ProcessorContractAnnouncement } from "./processor-contracts.ts";
-import type { EventConsumptionMetrics } from "./event-consumption-metrics.ts";
-import type { ProcessorRuntimeContribution } from "./stream-processor.ts";
-/**
- * The processor surface shared by the Durable Object registry
- * (stream-processor-registry.ts) and the browser host (stream-browser-store.ts):
- * the contract description returned by `wakeStreamProcessor`, the
- * processor-contributed runtime bag, and self-measured event-consumption metrics.
- * Deliberately NOT the drive surface — cursors, snapshots, and delivery live
- * in the StreamProcessorRunner, which reaches the protected hooks through
- * `StreamProcessor.runnerHooks`.
- */
-export type AnyHostedProcessor = {
-    contract: {
-        slug: string;
-        version: string;
-        description: string;
-        stateSchema: z.ZodType;
-        consumes: readonly string[];
-        emits: readonly string[];
-        events: Record<string, {
-            description?: string;
-            payloadSchema?: unknown;
-        }>;
-    };
-    /** The processor-contributed runtime bag; the snapshot half comes from the runner. */
-    getRuntimeState(): Promise<ProcessorRuntimeContribution>;
-    readonly eventConsumptionMetrics: Pick<EventConsumptionMetrics, "report" | "notePingObserved" | "noteAppendCommitted" | "clearPendingAppends">;
-};
-/**
- * The two live capabilities every processor host hands the stream alongside
- * its event-batch callback, shared by the DO registry and browser runtime so they cannot
- * drift. `getRuntimeState` assembles the published shape from its two honest
- * sources: the SNAPSHOT from the runner (`opts.snapshot` — the cursor owner),
- * the `runtime` bag from the processor, with the self-measured metrics merged
- * in host-side so a subclass override cannot accidentally drop them.
- */
-export declare function hostRuntimeCapabilities(processor: AnyHostedProcessor, opts: {
-    now: () => number;
-    /** The driving runner's committed snapshot (`() => runner.snapshot()`). */
-    snapshot: () => Promise<ProcessorSnapshot<unknown>>;
-    oneWayEstimateMs?: () => number | undefined;
-}): {
-    getRuntimeState: GetProcessorRuntimeState;
-    ping: StreamConnectionPing;
-};
-/** Serializable processor contract carried by server and browser hosts. */
-export declare function announceContract(contract: {
-    slug: string;
-    version: string;
-    description: string;
-    consumes: readonly string[];
-    emits: readonly string[];
-    events: Record<string, {
-        description?: string;
-        payloadSchema?: unknown;
-    }>;
-}): ProcessorContractAnnouncement;

package/dist/processors/prompt-sections.d.ts

@@ -1,17 +0,0 @@
-export type PromptSection = {
-    key: string;
-    content: string;
-};
-/**
- * Parse a prompt file's authoring syntax into sections, in file order.
- * Content inside `<section key="x">...</section>` becomes a section with
- * that key; content outside any tag (including a whole untagged file)
- * becomes a section with `fallbackKey` — so an untagged prompt file parses
- * to one section and keeps working unchanged. Throws on malformed authoring
- * (unclosed or nested tags): this runs at append time, where a loud failure
- * beats silently shipping tag soup to a model.
- */
-export declare function parsePromptSections(input: {
-    content: string;
-    fallbackKey: string;
-}): PromptSection[];