@fungi.computer/oyster 0.2.0 → 0.3.0

package/dist/standalone/workflows.js

@@ -10,13 +10,16 @@ import { createStandaloneWorkflowSchedules, } from "./workflow-schedules.js";
 import { createStandaloneWorkflowEvents, } from "./workflow-events.js";
 import { createStandaloneWorkflowTriggerHost, standaloneTriggerErrors, } from "./workflow-trigger-host.js";
 import { createWorkflowPublishedDefinitionPort, readPublishedWorkflow, } from "@fungi.computer/workflows-wire";
+import { workflowAgentAuthority } from "../workflow-agent-authority.js";
 import { defaultTenant, tenantScope } from "../tenant.js";
 import { AppInstanceError } from "../index.js";
-import { workflowGitPassPrefix } from "../git.js";
 import { createWorkflowGitPasses, createWorkflowGitPassStore, workflowGitPassWriter, workflowRunReport, wireRunInitiator, } from "@fungi.computer/braid/runtime";
 import { canonicalJson } from "@fungi.computer/braid";
 import { runKey, reviewKey, workflowGitPassRequestSchema, } from "./workflow-binding.js";
 import { agentDirectoryForScope } from "./agent-directory.js";
+import { createWorkflowWebhooks, workflowWebhookCommandSchema, workflowWebhookControlResponse, } from "../webhooks.js";
+import { workflowWebhookRefusal } from "../webhook-ingress.js";
+import { Hono } from "hono";
 /** SQLite and the native Workflow binding belong to this standalone host; its root supplies `hostFor`. */
 export class StandaloneWorkflowRunsBase extends DurableObject {
     composed;
@@ -37,7 +40,7 @@ export class StandaloneWorkflowRunsBase extends DurableObject {
     ) STRICT`);
         this.composed = ctx.blockConcurrencyWhile(async () => {
             const shared = await standaloneTenancy(env);
-            const host = this.hostFor(tenantScope(defaultTenant, env.OYSTER_ORIGIN));
+            const host = await this.hostFor(tenantScope(defaultTenant, env.OYSTER_ORIGIN));
             const agentToolPolicy = async (agentId) => (await host.appToolPolicy?.({ kind: "agent", agentId })) ?? null;
             // A key's App access is its own grants (Ear Tag), read through
             // `host.keys.live`, never through `appToolPolicy`.
@@ -45,6 +48,15 @@ export class StandaloneWorkflowRunsBase extends DurableObject {
             // The one owner reaches every Agent; the report needs one that exists.
             const admitDelivery = (_memberId, delivery) => agentDirectoryForScope(env, tenantScope(defaultTenant, env.OYSTER_ORIGIN)).has(delivery.agentId);
             const owner = createStandaloneWorkflowHost(ctx.storage, host, {
+                async lifecycleMember() {
+                    const member = await shared.owner();
+                    return member === null
+                        ? null
+                        : {
+                            memberId: member.actor.memberId,
+                            membershipVersion: member.membershipVersion,
+                        };
+                },
                 authority(libraryInstallationId) {
                     return createStandaloneWorkflowRootAuthority({
                         shared,
@@ -80,6 +92,7 @@ export class StandaloneWorkflowRunsBase extends DurableObject {
                         sql: ctx.storage.sql,
                         transactionSync: (body) => ctx.storage.transactionSync(body),
                         teamId: () => libraryId,
+                        now: () => this.scheduleClock.now(),
                     },
                     triggers: {
                         published: createWorkflowPublishedDefinitionPort((git) => ({
@@ -93,10 +106,20 @@ export class StandaloneWorkflowRunsBase extends DurableObject {
                                 memberId,
                             });
                         },
-                        // Standalone has no Connector-attachment store (Hub's own
-                        // mechanism for Agent arming); an Agent's owner-approved tool
-                        // policy governs dispatch, not arming here. See W-1/B-4(b).
-                        readAgentAccess: () => Promise.resolve(null),
+                        readAgentAccess: async (lookup) => {
+                            if (lookup.kind !== "policy")
+                                return null;
+                            const policy = await agentToolPolicy(lookup.agentId);
+                            return policy === null
+                                ? null
+                                : {
+                                    kind: "policy",
+                                    agentId: lookup.agentId,
+                                    policyRevision: policy.revision,
+                                    grantorMemberId: policy.grantedBy,
+                                    level: policy.level,
+                                };
+                        },
                         // The member's current Workflows Git policy; mints no pass itself.
                         admitGitAccess: async (memberId, repository, scope) => {
                             if (!(await gitAccess(libraryId)(memberId, repository, scope)))
@@ -122,20 +145,71 @@ export class StandaloneWorkflowRunsBase extends DurableObject {
                         const admitted = await owner.admitInvocation(facts, operation);
                         if (admitted.libraryId !== libraryId)
                             throw new AppInstanceError("revoked");
-                        return admitted;
+                        return {
+                            ...admitted,
+                            authority: await workflowAgentAuthority(facts, operation, agentToolPolicy),
+                        };
                     },
                 };
-                return {
-                    schedules: createStandaloneWorkflowSchedules({
-                        ...controls,
+                let webhooks = null;
+                const wake = async () => {
+                    const due = [
+                        schedules.nextWake(),
+                        webhooks?.nextWake() ?? null,
+                    ].filter((value) => value !== null);
+                    if (due.length === 0)
+                        await ctx.storage.deleteAlarm();
+                    else
+                        await ctx.storage.setAlarm(this.scheduleClock.alarmAt(Math.min(...due)));
+                };
+                const schedules = createStandaloneWorkflowSchedules({
+                    ...controls,
+                    now: () => this.scheduleClock.now(),
+                    wake,
+                    reportFailure: ({ source, cause }) => {
+                        console.error("Standalone Workflow schedule failed", source, cause);
+                    },
+                });
+                if (env.WORKFLOW_WEBHOOK_HOST_RATE !== undefined &&
+                    env.WORKFLOW_WEBHOOK_BINDING_RATE !== undefined &&
+                    env.WORKFLOW_WEBHOOK_POLICY !== undefined)
+                    webhooks = createWorkflowWebhooks({
+                        sql: ctx.storage.sql,
+                        transactionSync: (body) => ctx.storage.transactionSync(body),
                         now: () => this.scheduleClock.now(),
-                        wake: (due) => due === null
-                            ? ctx.storage.deleteAlarm()
-                            : ctx.storage.setAlarm(this.scheduleClock.alarmAt(due)),
-                        reportFailure: ({ source, cause }) => {
-                            console.error("Standalone Workflow schedule failed", source, cause);
+                        scope: { host: env.OYSTER_ORIGIN, tenant: libraryId },
+                        owner: async (principal) => {
+                            const current = await shared.owner();
+                            return principal.actor.kind === "member" &&
+                                current?.actor.memberId === principal.actor.memberId
+                                ? principal.actor.memberId
+                                : null;
+                        },
+                        runs: triggers.runs,
+                        triggers: triggers.triggers,
+                        launch: async (run) => {
+                            const stored = triggers.runs.graph.read(run.runId);
+                            if (stored === null)
+                                throw new Error("Reserved Workflow run is missing");
+                            // Recover the existing run's dispatch context after a crash between
+                            // durable admission and the standalone adapter's caller write.
+                            owner.recordTriggerCaller(run.runId, stored.actorId, stored.computerId);
+                            await this.launch(libraryId, run);
+                        },
+                        abuse: {
+                            hostRate: env.WORKFLOW_WEBHOOK_HOST_RATE,
+                            bindingRate: env.WORKFLOW_WEBHOOK_BINDING_RATE,
+                            concurrency: env.WORKFLOW_WEBHOOK_POLICY.concurrency,
+                        },
+                        limits: env.WORKFLOW_WEBHOOK_POLICY.limits,
+                        wake,
+                        reportFailure: () => {
+                            console.error("Standalone Workflow webhook failed");
                         },
-                    }),
+                    });
+                return {
+                    schedules,
+                    webhooks,
                     events: createStandaloneWorkflowEvents(controls),
                 };
             };
@@ -151,13 +225,12 @@ export class StandaloneWorkflowRunsBase extends DurableObject {
                 transactionSync: (body) => ctx.storage.transactionSync(body),
                 ownerId: () => this.libraryId(),
                 computerId: () => computerId,
-                mintPassId: () => Array.from(crypto.getRandomValues(new Uint8Array(32)), (byte) => byte.toString(16).padStart(2, "0")).join(""),
-                remote: (_passId, repository) => {
+                remote: (repository) => {
                     const libraryId = this.libraryId();
                     if (repository.kind !== "installation" || libraryId === null)
                         throw new AppInstanceError("revoked");
-                    // The tenant's ordinary smart-HTTP door; the pass never enters the
-                    // URL and travels only as the bearer header.
+                    // The tenant's ordinary smart-HTTP door; the credential never
+                    // enters the URL and travels only as the bearer header.
                     return new URL(`/git/${repository.installationId}/${repository.repository}.git`, env.OYSTER_ORIGIN).href;
                 },
                 denied: () => new AppInstanceError("revoked"),
@@ -184,13 +257,6 @@ export class StandaloneWorkflowRunsBase extends DurableObject {
                         if (!(await access(memberId, repository, scope)))
                             throw new AppInstanceError("revoked");
                     },
-                    open: (_computer, grant) => {
-                        const pass = passStore.openWorkflowPass(grant);
-                        return Promise.resolve({
-                            ...pass,
-                            bearer: `${workflowGitPassPrefix}${libraryId}.${pass.passId}`,
-                        });
-                    },
                     revoke: (_computer, input) => {
                         passStore.revokeWorkflowRunGitPasses(input);
                         return Promise.resolve();
@@ -200,8 +266,20 @@ export class StandaloneWorkflowRunsBase extends DurableObject {
                     acknowledge: () => undefined,
                 });
             };
-            return { owner, libraryTriggers, passStore, gitAccess, gitPasses };
+            return {
+                owner,
+                libraryTriggers,
+                passStore,
+                gitAccess,
+                gitPasses,
+                computerId,
+            };
         });
+        ctx.waitUntil(this.composed.then(async ({ libraryTriggers }) => {
+            const libraryId = this.libraryId();
+            if (libraryId !== null)
+                await libraryTriggers(libraryId).webhooks?.recover();
+        }));
         this.owner = this.composed.then(({ owner }) => owner);
     }
     /** Record the library this object serves; another name is a revocation. */
@@ -213,11 +291,12 @@ export class StandaloneWorkflowRunsBase extends DurableObject {
             this.ctx.storage.sql.exec("INSERT INTO standalone_workflow_library(singleton,installation_id) VALUES(1,?)", libraryId);
     }
     /**
-     * Mint (or renew) the Git pass for the Git step a node frame is executing.
-     * Null when this library dispatched no such step; a step that does not match
-     * the frame's attested Workflow, member and Computer is a revocation.
+     * Admit the Git step a node frame is executing: its public grant, never a
+     * credential. Null when this library dispatched no such step; a step that
+     * does not match the frame's attested Workflow, member and Computer is a
+     * revocation. Only NEW native admission then issues, through issueWorkflowGit.
      */
-    async openWorkflowGitPass(raw) {
+    async admitWorkflowGit(raw) {
         const request = workflowGitPassRequestSchema.parse(raw);
         const { owner, gitPasses } = await this.composed;
         const libraryId = this.libraryId();
@@ -234,18 +313,37 @@ export class StandaloneWorkflowRunsBase extends DurableObject {
             canonicalJson(node.context.armedBy) !==
                 canonicalJson(request.workflow.armedBy))
             throw new AppInstanceError("revoked");
-        return gitPasses(libraryId).openWorkflowPass(node.context, {
+        return gitPasses(libraryId).admitWorkflowGit(node.context, {
             installationId: node.installationId,
             method: node.method,
         });
     }
-    /** The tenant Git door's per-request admission of a presented pass. */
-    async admitWorkflowGitPass(passId, repository, scope) {
-        const { owner, passStore, gitAccess } = await this.composed;
+    /** One fresh credential for a NEW native invocation of an admitted step. */
+    async issueWorkflowGit(invocationId, grant) {
+        const { passStore } = await this.composed;
+        return await passStore.issue(invocationId, grant);
+    }
+    /** A live native replay extends its lease; it never issues another. */
+    async renewWorkflowGit(invocationId, grant) {
+        const { passStore } = await this.composed;
+        passStore.renew(invocationId, grant);
+    }
+    /** Close an invocation's credential, even before its issue arrives. */
+    async closeWorkflowGit(invocationId, grant) {
+        const { passStore } = await this.composed;
+        passStore.close(invocationId, grant);
+    }
+    /** The tenant Git door's per-request admission of a presented bearer. */
+    async admitWorkflowGitPass(bearer, repository, scope) {
+        const { owner, passStore, gitAccess, computerId } = await this.composed;
         const libraryId = this.libraryId();
-        const grant = passStore.admit({ passId, repository, scope });
-        if (libraryId === null ||
-            grant === null ||
+        const admitted = await passStore.admit({ bearer, repository, scope });
+        if (libraryId === null || admitted === null || computerId === undefined)
+            return null;
+        const { grant, invocationId } = admitted;
+        if (
+        // The selected Computer proves the credential's native command live.
+        !(await this.env.COMPUTER.getByName(computerId).executionIsLive(invocationId)) ||
             owner.store.outcome(grant.runId) !== "active" ||
             !(await gitAccess(libraryId)(grant.memberId, repository, scope)))
             return null;
@@ -347,6 +445,42 @@ export class StandaloneWorkflowRunsBase extends DurableObject {
         if (libraryId === null)
             return;
         await libraryTriggers(libraryId).schedules.alarm();
+        await libraryTriggers(libraryId).webhooks?.recover();
+    }
+    /** Signed traffic uses the native fetch interface; no sender principal is accepted. */
+    async fetch(request) {
+        return new Hono()
+            .all("/webhooks/:bindingId", async (context) => {
+            const { libraryTriggers } = await this.composed;
+            const libraryId = this.libraryId();
+            const webhooks = libraryId === null ? null : libraryTriggers(libraryId).webhooks;
+            return webhooks === null
+                ? workflowWebhookRefusal()
+                : webhooks.receive(context.req.param("bindingId"), context.req.raw);
+        })
+            .fetch(request);
+    }
+    async #isWebhookOwner(principal) {
+        const shared = await standaloneTenancy(this.env);
+        const current = await shared.owner();
+        return (principal.actor.kind === "member" &&
+            current?.actor.memberId === principal.actor.memberId);
+    }
+    /** Root-authenticated owner RPC; command data cannot nominate an actor or pin. */
+    async webhookControl(principal, installationId, raw) {
+        if (!(await this.#isWebhookOwner(principal)))
+            return workflowWebhookRefusal();
+        const parsed = workflowWebhookCommandSchema.safeParse(raw);
+        if (!parsed.success)
+            return workflowWebhookRefusal();
+        const { owner, libraryTriggers } = await this.composed;
+        const webhooks = libraryTriggers(installationId).webhooks;
+        if (webhooks === null)
+            return workflowWebhookRefusal();
+        return workflowWebhookControlResponse(webhooks, principal, parsed.data, async (target) => ({
+            target: { ...target, installationId },
+            authority: (await owner.triggerAuthority(installationId)).pin,
+        }));
     }
     /**
      * The emitting App's Instance delivers each accepted event here. The
@@ -465,6 +599,13 @@ export class StandaloneWorkflowRunsBase extends DurableObject {
         const run = owner.store.read(runId);
         if (run?.teamId !== installationId)
             return { error: "not_found" };
+        return this.runStatus(runId);
+    }
+    async runStatus(runId) {
+        const owner = await this.owner;
+        const run = owner.store.read(runId);
+        if (run === null)
+            return null;
         const outcome = owner.store.outcome(runId);
         let status;
         try {
@@ -499,6 +640,24 @@ export class StandaloneWorkflowRunsBase extends DurableObject {
         const run = owner.store.read(runId);
         if (run?.teamId !== installationId)
             return { kind: "refused", reason: "denied" };
+        return this.cancelRun(runId);
+    }
+    /** Host-only MCP control reopens the configured owner's authority on every call. */
+    async control(principal, operation, runId) {
+        const shared = await standaloneTenancy(this.env);
+        const current = await shared.owner();
+        if (principal.actor.kind !== "member" ||
+            current?.actor.memberId !== principal.actor.memberId)
+            throw new AppInstanceError("revoked");
+        const owner = await this.owner;
+        if (owner.store.read(runId) === null)
+            return null;
+        return operation === "status"
+            ? this.runStatus(runId)
+            : this.cancelRun(runId);
+    }
+    async cancelRun(runId) {
+        const owner = await this.owner;
         if (owner.store.outcome(runId) !== "active")
             return { kind: "terminal" };
         const instance = await this.env.GRAPH_WORKFLOWS.get(runId);

package/dist/storage-frame.d.ts

@@ -8,7 +8,7 @@ export declare const storageFrameMethods: {
                 readonly kind: "accepted";
                 readonly value: {
                     readonly value: Schema.Json;
-                    readonly source: "team" | "member" | "none";
+                    readonly source: "member" | "team" | "none";
                     readonly team: {
                         readonly value: Schema.Json;
                         readonly revision: number;
@@ -21,7 +21,7 @@ export declare const storageFrameMethods: {
                 };
             } | {
                 readonly kind: "rejected";
-                readonly code: "unavailable" | "invalid" | "undeclared_key" | "scope_not_declared" | "owner_required" | "too_large" | "quota_exceeded" | "conflict";
+                readonly code: "unavailable" | "invalid" | "conflict" | "undeclared_key" | "scope_not_declared" | "owner_required" | "too_large" | "quota_exceeded";
             };
             requiredOperations: () => string[];
         };
@@ -29,7 +29,7 @@ export declare const storageFrameMethods: {
             decodeArgs: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => readonly [{
                 readonly value: Schema.Json;
                 readonly key: string;
-                readonly scope: "team" | "member";
+                readonly scope: "member" | "team";
                 readonly basedOn: number | null;
             }];
             decodeResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => {
@@ -39,14 +39,14 @@ export declare const storageFrameMethods: {
                 };
             } | {
                 readonly kind: "rejected";
-                readonly code: "unavailable" | "invalid" | "undeclared_key" | "scope_not_declared" | "owner_required" | "too_large" | "quota_exceeded" | "conflict";
+                readonly code: "unavailable" | "invalid" | "conflict" | "undeclared_key" | "scope_not_declared" | "owner_required" | "too_large" | "quota_exceeded";
             };
             requiredOperations: () => string[];
         };
         reset: {
             decodeArgs: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => readonly [{
                 readonly key: string;
-                readonly scope: "team" | "member";
+                readonly scope: "member" | "team";
                 readonly basedOn: number | null;
             }];
             decodeResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => {
@@ -56,7 +56,7 @@ export declare const storageFrameMethods: {
                 };
             } | {
                 readonly kind: "rejected";
-                readonly code: "unavailable" | "invalid" | "undeclared_key" | "scope_not_declared" | "owner_required" | "too_large" | "quota_exceeded" | "conflict";
+                readonly code: "unavailable" | "invalid" | "conflict" | "undeclared_key" | "scope_not_declared" | "owner_required" | "too_large" | "quota_exceeded";
             };
             requiredOperations: () => string[];
         };

package/dist/testing/capabilities.js

@@ -72,12 +72,20 @@ export async function capabilityFixture(options = {}) {
         descriptors: capabilities,
     });
     if (options.admitted === false)
-        installation = { ...installation, approvedGrants: [], approval: null };
+        installation = {
+            ...installation,
+            authority: {
+                ...installation.authority,
+                approvedGrants: [],
+                approval: null,
+            },
+        };
     // An anonymous reader reaches only a public App, as the host's visitor.
     if (options.visitor)
         installation = { ...installation, visibility: "public" };
     const readOnly = () => Promise.reject(new Error("Fixture installations are read-only"));
     const base = {
+        bootUi: () => Promise.resolve({ kind: "passed" }),
         auth: {
             resolve: () => Promise.reject(new Error("Capability fixture resolves no actor")),
             authenticate: options.authenticate ??
@@ -96,9 +104,9 @@ export async function capabilityFixture(options = {}) {
             put: () => Promise.reject(new Error("Fixture artifacts are read-only")),
         },
         installations: {
+            generation: () => Promise.resolve("fixture-generation"),
             list: () => Promise.resolve([installation]),
             get: (id) => Promise.resolve(id === installation.installationId ? installation : null),
-            put: readOnly,
             compareAndPut: readOnly,
         },
         instances: {
@@ -123,7 +131,10 @@ export async function capabilityFixture(options = {}) {
             installation = {
                 ...installation,
                 release: await release("rel_undeclared", []),
-                authorityVersion: installation.authorityVersion + 1,
+                authority: {
+                    ...installation.authority,
+                    authorityVersion: installation.authority.authorityVersion + 1,
+                },
             };
         },
     };

package/dist/testing/installation.js

@@ -1,3 +1,4 @@
+import { permissionCatalog } from "../apps/catalog.js";
 import * as Result from "effect/Result";
 import { applyInstallationCommand, deriveDeclaredOperations, } from "../apps/index.js";
 /** Build fixture state through the same approval owner used by installation routes. */
@@ -6,7 +7,6 @@ export async function approvedInstallation(input) {
         kind: "install",
         release: input.release,
         releasePin: "pinned",
-        grants: "declared",
     }, {
         by: { kind: "member", memberId: "fixture-owner" },
         role: "owner",
@@ -21,5 +21,29 @@ export async function approvedInstallation(input) {
     });
     if (Result.isFailure(result))
         throw new Error(result.failure.code);
-    return { ...result.success.next, visibility: input.visibility ?? "private" };
+    const installed = result.success.next;
+    const declaredOperations = await deriveDeclaredOperations(input.release, input.declaration, input.descriptors ?? []);
+    const changes = declaredOperations.capabilities
+        .filter(({ capability }) => permissionCatalog[capability].consent === "ask")
+        .map(({ capability, operations }) => ({
+        capability,
+        grant: { operations, resources: "tenant-scope" },
+    }));
+    if (changes.length === 0)
+        return { ...installed, visibility: input.visibility ?? "private" };
+    const approved = applyInstallationCommand(installed, { kind: "change-grants", changes }, {
+        by: { kind: "member", memberId: "fixture-owner" },
+        role: "owner",
+        expectedVersion: installed.authority.authorityVersion,
+        declaration: input.declaration,
+        declaredOperations,
+        now: 1001,
+        identity: installed,
+    });
+    if (Result.isFailure(approved))
+        throw new Error(approved.failure.code);
+    return {
+        ...approved.success.next,
+        visibility: input.visibility ?? "private",
+    };
 }

package/dist/testing/worker.js

@@ -16,7 +16,7 @@ export class ConfiguredInstance extends DurableObject {
         this.catalog = createFixtureCatalog(env.CATALOG_FIXTURE);
         this.gate = createCloudflareInvocationGate(ctx, () => Promise.resolve());
         void ctx.blockConcurrencyWhile(() => seedFixtureCatalog(env.CATALOG_FIXTURE, this.catalog));
-        this.runtime = createCloudflareAppInstance(ctx, env.LOADER, (id) => resolveDurableBackend(this.catalog, id).pipe(Effect.mapError((error) => new Error(String(error)))), () => ({}));
+        this.runtime = createCloudflareAppInstance(ctx, env.LOADER, (id) => resolveDurableBackend(this.catalog, id).pipe(Effect.mapError((error) => new Error(String(error)))), () => ({}), () => Promise.resolve(null));
     }
     async fetch(request) {
         const url = new URL(request.url);

package/dist/testing/workers-runtime.d.ts

@@ -1,9 +1,15 @@
 /**
- * Node stand-in for `cloudflare:workers` and `cloudflare:workflows`: only the
- * platform constructors are replaced, so adapters and SQLite run unchanged.
+ * Node-only stand-in for `cloudflare:workers` and `cloudflare:workflows`. It
+ * supplies constructors, an explicit retained-work recorder for tests, and
+ * empty binding lookup; no Cloudflare service or lifetime semantics are
+ * supplied. Adapters and SQLite run unchanged.
  * Resolve it with `import.meta.resolve("@fungi.computer/oyster/testing/workers-runtime")`
  * from a module hook.
  */
+export declare const env: {};
+/** Node tests retain and explicitly drain the same platform-owned work. */
+export declare function waitUntil(promise: Promise<unknown>): void;
+export declare function drainWaitUntil(): Promise<void>;
 export declare class DurableObject<Env = unknown> {
     readonly ctx: DurableObjectState;
     readonly env: Env;

package/dist/testing/workers-runtime.js

@@ -1,9 +1,27 @@
 /**
- * Node stand-in for `cloudflare:workers` and `cloudflare:workflows`: only the
- * platform constructors are replaced, so adapters and SQLite run unchanged.
+ * Node-only stand-in for `cloudflare:workers` and `cloudflare:workflows`. It
+ * supplies constructors, an explicit retained-work recorder for tests, and
+ * empty binding lookup; no Cloudflare service or lifetime semantics are
+ * supplied. Adapters and SQLite run unchanged.
  * Resolve it with `import.meta.resolve("@fungi.computer/oyster/testing/workers-runtime")`
  * from a module hook.
  */
+export const env = {};
+const retainedWork = new Set();
+/** Node tests retain and explicitly drain the same platform-owned work. */
+export function waitUntil(promise) {
+    retainedWork.add(Promise.resolve(promise).then(() => ({ kind: "completed" }), (cause) => ({
+        kind: "failed",
+        causeKind: cause instanceof Error ? cause.name : "non-error rejection",
+    })));
+}
+export async function drainWaitUntil() {
+    const outcomes = await Promise.all(retainedWork);
+    retainedWork.clear();
+    const failure = outcomes.find((outcome) => outcome.kind === "failed");
+    if (failure?.kind === "failed")
+        throw new Error(`Retained Worker work failed: ${failure.causeKind}`);
+}
 export class DurableObject {
     ctx;
     env;

package/dist/webhook-abuse.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import type { RateLimit } from "@cloudflare/workers-types";
+declare const webhookConcurrencySchema: z.ZodObject<{
+    hostConcurrency: z.ZodNumber;
+    bindingConcurrency: z.ZodNumber;
+}, z.core.$strict>;
+/** Native rate bindings own quotas; this adapter never implements a rate clock. */
+export declare function workflowWebhookAbuse(options: {
+    scope: Readonly<{
+        host: string;
+        tenant: string;
+    }>;
+    hostRate: Pick<RateLimit, "limit">;
+    bindingRate: Pick<RateLimit, "limit">;
+    concurrency: z.input<typeof webhookConcurrencySchema>;
+}): {
+    concurrency: {
+        hostConcurrency: number;
+        bindingConcurrency: number;
+    };
+    /** Per-instance streaming bound; durable run concurrency belongs to Braid. */
+    hostLease(): Promise<null | (() => void)>;
+    bindingAdmission(bindingId: string): Promise<boolean>;
+};
+export {};

package/dist/webhook-abuse.js

@@ -0,0 +1,54 @@
+import { z } from "zod";
+import { createHash } from "node:crypto";
+// The maintained edge rate-limit contract bounds keys to 256 characters.
+// Hash the full scoped tuple, rather than truncating identities or depending
+// on a provider to accept an oversized concatenation.
+const rateKey = (parts) => createHash("sha256").update(JSON.stringify(parts)).digest("hex");
+const webhookConcurrencySchema = z.strictObject({
+    hostConcurrency: z.number().int().positive(),
+    bindingConcurrency: z.number().int().positive(),
+});
+/** Native rate bindings own quotas; this adapter never implements a rate clock. */
+export function workflowWebhookAbuse(options) {
+    const scope = z
+        .strictObject({
+        host: z.string().min(1).max(256),
+        tenant: z.string().min(1).max(256),
+    })
+        .parse(options.scope);
+    const concurrency = webhookConcurrencySchema.parse(options.concurrency);
+    const prefix = ["workflow-webhooks", scope.host, scope.tenant];
+    let active = 0;
+    return {
+        concurrency,
+        /** Per-instance streaming bound; durable run concurrency belongs to Braid. */
+        async hostLease() {
+            if (active >= concurrency.hostConcurrency)
+                return null;
+            const { success } = await options.hostRate.limit({
+                key: rateKey(["workflow-webhooks", scope.host, "host"]),
+            });
+            // Native admission awaits I/O; simultaneous successful replies still
+            // cannot overbook the local streaming ceiling.
+            if (!success || active >= concurrency.hostConcurrency)
+                return null;
+            active++;
+            let released = false;
+            return () => {
+                if (released)
+                    return;
+                released = true;
+                active--;
+            };
+        },
+        async bindingAdmission(bindingId) {
+            const id = z.string().min(1).max(256).safeParse(bindingId);
+            if (!id.success)
+                return false;
+            const { success } = await options.bindingRate.limit({
+                key: rateKey([...prefix, "binding", id.data]),
+            });
+            return success;
+        },
+    };
+}