@cat-factory/gatekeeper-worker 0.4.3 → 0.5.0

package/dist/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../src/markdown.ts"],"names":[],"mappings":"AAaA;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,SAAS,GAAG,MAAM,CAOjE"}

package/dist/markdown.js

@@ -0,0 +1,28 @@
+// The one Markdown-safety primitive this Worker needs.
+//
+// Every description this Gatekeeper composes is MARKDOWN rendered to a person who is about to
+// decide something, and several of the holes in it carry text an agent or a task author wrote: the
+// argument bag of a call, the title of an approval card. Those are parsed surfaces, not inert
+// string sinks, and the failure is not cosmetic: an unbalanced fence swallows everything after it,
+// so a payload closing the block early makes the rest of OUR prose render as the payload's, right
+// where "here is what you are approving" is being said.
+//
+// It sits beside `masking.ts` rather than inside `os/` because both doors compose descriptions and
+// neither owns the rule. It is the same sizing rule the platform's own `fencedOutput` uses for
+// captured command output reaching a model.
+/**
+ * Fence a payload so it cannot break out of the code block that holds it.
+ *
+ * Sized one backtick longer than the longest run the payload contains, which is what makes it
+ * total: a payload holding ```` closes a ``` fence and everything after it, including the rest of
+ * the description, renders as prose the reader takes for ours.
+ *
+ * The language tag is the caller's, because a JSON argument bag and a free-text title are both
+ * fenced and only one of them is JSON.
+ */
+export function fenced(payload, language = 'json') {
+    const longestRun = [...payload.matchAll(/`+/g)].reduce((longest, match) => Math.max(longest, match[0].length), 0);
+    const fence = '`'.repeat(Math.max(3, longestRun + 1));
+    return `${fence}${language}\n${payload}\n${fence}`;
+}
+//# sourceMappingURL=markdown.js.map

package/dist/markdown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.js","sourceRoot":"","sources":["../src/markdown.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,EAAE;AACF,8FAA8F;AAC9F,mGAAmG;AACnG,8FAA8F;AAC9F,mGAAmG;AACnG,kGAAkG;AAClG,wDAAwD;AACxD,EAAE;AACF,mGAAmG;AACnG,+FAA+F;AAC/F,4CAA4C;AAE5C;;;;;;;;;GASG;AACH,MAAM,UAAU,MAAM,CAAC,OAAe,EAAE,QAAQ,GAAG,MAAM;IACvD,MAAM,UAAU,GAAG,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CACpD,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,EACtD,CAAC,CACF,CAAA;IACD,MAAM,KAAK,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,UAAU,GAAG,CAAC,CAAC,CAAC,CAAA;IACrD,OAAO,GAAG,KAAK,GAAG,QAAQ,KAAK,OAAO,KAAK,KAAK,EAAE,CAAA;AACpD,CAAC"}

package/dist/os/account.d.ts

@@ -0,0 +1,27 @@
+import type { GatekeeperEnv } from '../env.js';
+import type { GatekeeperPolicy } from '../policy/compile.js';
+import type { AccountEntrypoint, VerifierEntrypoint } from './protocol.js';
+/** What the vendor imbues an account with. The id IS the account; nothing else is stored. */
+export interface AccountProps {
+    accountId: string;
+}
+/**
+ * The account entrypoint over a deployment's policy.
+ *
+ * Stateless by construction: the workspace holds the stub, the stub holds the id, and everything
+ * else is resolved from the policy and the paired deployment on each call. There is no account
+ * table to fall out of step with the workspace's own.
+ */
+export declare function createGatekeeperAccount(options: {
+    policy: GatekeeperPolicy;
+}): new (ctx: ExecutionContext<AccountProps>, env: GatekeeperEnv) => AccountEntrypoint;
+/**
+ * The verifier: an identity token with no authority.
+ *
+ * The contract's own interface is empty, because what is being passed IS the identity: another
+ * gatekeeper asks the workspace whether the holder of this stub may see something, and never calls
+ * a method on it. `describe()` is here so a human looking at a share prompt sees which account is
+ * being named rather than an opaque stub.
+ */
+export declare function createGatekeeperVerifier(): new (ctx: ExecutionContext<AccountProps>, env: GatekeeperEnv) => VerifierEntrypoint;
+//# sourceMappingURL=account.d.ts.map

package/dist/os/account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account.d.ts","sourceRoot":"","sources":["../../src/os/account.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAG9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAE5D,OAAO,KAAK,EAEV,iBAAiB,EAEjB,kBAAkB,EACnB,MAAM,eAAe,CAAA;AAItB,6FAA6F;AAC7F,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE;IAC/C,MAAM,EAAE,gBAAgB,CAAA;CACzB,GAAG,KAAK,GAAG,EAAE,gBAAgB,CAAC,YAAY,CAAC,EAAE,GAAG,EAAE,aAAa,KAAK,iBAAiB,CA8FrF;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,IAAI,KAC1C,GAAG,EAAE,gBAAgB,CAAC,YAAY,CAAC,EACnC,GAAG,EAAE,aAAa,KACf,kBAAkB,CAMtB"}

package/dist/os/account.js

@@ -0,0 +1,130 @@
+// One connected account, and the identity story behind it.
+//
+// The published contract's normal path is OAuth: a user connects their own vendor account through a
+// nonce-protected flow, and identity thereafter travels as a props-imbued stub the workspace
+// persists. cat-factory has no per-user OAuth, so this vendor takes the contract's own escape
+// hatch: `autoProvisionsAccount`, where the workspace mints one account per user with no flow at
+// all. That is a recognised low-trust variant rather than a violation, and it is worth being exact
+// about what it does and does not buy.
+//
+// `createAccount()` "takes no arguments, so it carries no user identity" (the spec's own words). So
+// the account's identity is one this Gatekeeper MINTS, and the workspace's persistence of the
+// returned stub is what makes it stable and per-user. Two consequences follow, and both are better
+// stated than discovered:
+//
+//   - The actor is stronger here than on `/rpc`, not weaker. `connect({ actorId })` trusts a string
+//     the caller sent; an account id was never in anyone's hands to assert.
+//   - A policy's `grants` map, keyed on an OS user identity an operator typed, cannot match an id
+//     nobody had yet when the policy was written. So an auto-provisioned account resolves to the
+//     policy's `autoProvisionedTier`, which is deliberately NOT `defaultTier` and does not inherit
+//     from it: naming one is how a deployment opts into Cloudflare OS discovery, and a policy that
+//     names none refuses, loudly, saying so. An operator who wants ONE account raised above it
+//     reads that account's id off `describe()` (`uniqueName`) and grants THAT id directly.
+import { WorkerEntrypoint } from 'cloudflare:workers';
+import { GatekeeperError } from '../errors.js';
+import { Gatekeeper } from '../gatekeeper.js';
+import { loopbackExport } from './exports.js';
+import { supportedResourceFor } from './resources.js';
+/**
+ * The account entrypoint over a deployment's policy.
+ *
+ * Stateless by construction: the workspace holds the stub, the stub holds the id, and everything
+ * else is resolved from the policy and the paired deployment on each call. There is no account
+ * table to fall out of step with the workspace's own.
+ */
+export function createGatekeeperAccount(options) {
+    const { policy } = options;
+    return class CatFactoryAccount extends WorkerEntrypoint {
+        #gatekeeper() {
+            return Gatekeeper.create(this.env, policy);
+        }
+        async describe() {
+            const gatekeeper = this.#gatekeeper();
+            const accountId = this.ctx.props.accountId;
+            const resource = supportedResourceFor(gatekeeper.deployment);
+            return {
+                // The id is surfaced as the canonical name because it is the value an operator needs in
+                // hand to grant this account a tier above the default, and the only place it is visible.
+                uniqueName: accountId,
+                displayName: `cat-factory (${gatekeeper.tierForAccount(accountId).name})`,
+                avatar: { url: new URL('/favicon.ico', gatekeeper.deployment).toString() },
+                grantedResourceUrlPatterns: [resource.urlPattern],
+            };
+        }
+        async getSupportedResources() {
+            return [supportedResourceFor(this.#gatekeeper().deployment)];
+        }
+        /**
+         * The resource object for a URL, imbued with this account's identity.
+         *
+         * The account id rides `ctx.props` onto the resource rather than being passed per call, which is
+         * what makes it unforgeable from the session side: an agent holding a session has no argument
+         * with which to name a different account.
+         */
+        async getGatekeeperClassFor(url) {
+            const gatekeeper = this.#gatekeeper();
+            const resource = supportedResourceFor(gatekeeper.deployment);
+            if (!new URLPattern(resource.urlPattern).test(url)) {
+                throw new GatekeeperError('no_such_resource', `This Gatekeeper serves ${resource.urlPattern} and nothing else, so it cannot bind ` +
+                    `${url}. It is paired with one cat-factory workspace by the provisioning key it ` +
+                    'holds; a second workspace takes a second Gatekeeper deployment.');
+            }
+            // The account, and nothing else: the URL is what was CHECKED, not what has to be carried.
+            // Every URL this pattern matches binds the same paired workspace, so recording which one a
+            // caller happened to name would be state no reader could act on (`ResourceProps`).
+            const props = { accountId: this.ctx.props.accountId };
+            return { class: loopbackExport(this.ctx.exports, 'resource', props), resource };
+        }
+        /** Nothing to grant: this vendor's single resource comes with the account. */
+        async ensureResources(_resourceUrlPatterns) {
+            return {};
+        }
+        /** Offboarding: revoke every cat-factory key this Gatekeeper minted for the account. */
+        async revoke() {
+            await this.#gatekeeper().retire(this.ctx.props.accountId);
+        }
+        /**
+         * Identity carried into another vendor's gatekeeper, and NOTHING else.
+         *
+         * A separate export rather than `this`, because the holder of a verifier is a third party's
+         * gatekeeper: handing it this object would hand it `revoke()` and the resource classes too.
+         */
+        async getVerifier() {
+            return loopbackExport(this.ctx.exports, 'verifier', {
+                accountId: this.ctx.props.accountId,
+            });
+        }
+        /** This vendor does not authenticate anybody: it auto-provisions, and says so in `describe()`. */
+        async getAuthenticatedEmail() {
+            return null;
+        }
+        /**
+         * There is no connect flow to re-run.
+         *
+         * An account's credentials are the per-account cat-factory keys this Gatekeeper mints, and a
+         * rejected one is already re-minted automatically on the next call. So the honest answer is a
+         * refusal naming the real remedy rather than a URL that would open nothing.
+         */
+        async reconnect() {
+            throw new GatekeeperError('unsupported_action', 'This vendor auto-provisions accounts and runs no connect flow, so there is nothing to ' +
+                'reconnect. If calls are failing on credentials, the deployment-level provisioning key ' +
+                'is the one to check; a per-account key is re-minted automatically when it is refused.');
+        }
+    };
+}
+/**
+ * The verifier: an identity token with no authority.
+ *
+ * The contract's own interface is empty, because what is being passed IS the identity: another
+ * gatekeeper asks the workspace whether the holder of this stub may see something, and never calls
+ * a method on it. `describe()` is here so a human looking at a share prompt sees which account is
+ * being named rather than an opaque stub.
+ */
+export function createGatekeeperVerifier() {
+    return class CatFactoryVerifier extends WorkerEntrypoint {
+        async describe() {
+            return { accountId: this.ctx.props.accountId };
+        }
+    };
+}
+//# sourceMappingURL=account.js.map

package/dist/os/account.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"account.js","sourceRoot":"","sources":["../../src/os/account.ts"],"names":[],"mappings":"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"}

package/dist/os/descriptions.d.ts

@@ -0,0 +1,43 @@
+import { type GatekeeperBinding } from '@cat-factory/gatekeeper-bindings';
+import type { ActionDescription, ActionKind, ObservationDescription } from './protocol.js';
+/** Who a described call is made as, for the approver reading it. */
+export interface CallSubject {
+    /** The account this session was opened for. */
+    accountId: string;
+    /** The policy tier that account resolved to. */
+    tier: string;
+    /** The paired deployment the call lands on. */
+    deployment: string;
+}
+/**
+ * Describe a read.
+ *
+ * `prohibitAllSharing` is set for exactly the operations the table marks as reading a telemetry
+ * sink, which are the ones that serve CAPTURED TEXT: model prompts and replies, tool arguments,
+ * agent search terms, provisioning output. Every one of those sits inside a `read` key's floor, so
+ * without this the platform's most sensitive reads would be shared onward on the same terms as a
+ * task list. The annotation already exists for the policy layer; this is the second consumer it
+ * was always going to have.
+ */
+export declare function describeObservation(binding: GatekeeperBinding, args: Record<string, unknown>, subject: CallSubject): ObservationDescription;
+/** The stable tag an OS pre-approval rule matches this operation by. */
+export declare function actionKindOf(binding: GatekeeperBinding): ActionKind;
+/**
+ * Describe a side effect.
+ *
+ * Three fields are fixed for every action this Gatekeeper submits, and each is a statement about
+ * what this implementation does rather than a default:
+ *
+ *   - `implementsRevert: false`. Reverting a started run, a merged pull request or a stopped job is
+ *     not something this Worker can do on the caller's behalf, and the flag exists precisely so the
+ *     UI does not offer an undo that would not work.
+ *   - `awaitDecision: true`. This Gatekeeper does not SIMULATE: there is no provisional run id to
+ *     hand an agent so it can keep working while a human decides. The spec's alternative for a
+ *     non-simulating gatekeeper is to suspend the agent's turn, which is what the flag asks for.
+ *   - `autoApprovable` follows the table's own consequence reading, with the cautious default
+ *     applied by `resolveConsequence`: an unannotated mutation is destructive, so it is NOT
+ *     offered for auto-approval. Being auto-approvable is still only permission for a user who
+ *     opted into this action's kind; it never approves anything by itself.
+ */
+export declare function describeAction(binding: GatekeeperBinding, args: Record<string, unknown>, subject: CallSubject): ActionDescription;
+//# sourceMappingURL=descriptions.d.ts.map

package/dist/os/descriptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptions.d.ts","sourceRoot":"","sources":["../../src/os/descriptions.ts"],"names":[],"mappings":"AAaA,OAAO,EAAsB,KAAK,iBAAiB,EAAE,MAAM,kCAAkC,CAAA;AAE7F,OAAO,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAA;AAE1F,oEAAoE;AACpE,MAAM,WAAW,WAAW;IAC1B,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAA;IACjB,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAA;IACZ,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAA;CACnB;AAsBD;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,iBAAiB,EAC1B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,WAAW,GACnB,sBAAsB,CAexB;AAED,wEAAwE;AACxE,wBAAgB,YAAY,CAAC,OAAO,EAAE,iBAAiB,GAAG,UAAU,CAEnE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,iBAAiB,EAC1B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,WAAW,GACnB,iBAAiB,CAoBnB"}

package/dist/os/descriptions.js

@@ -0,0 +1,100 @@
+// What the OS is told about a call, derived from the operation table rather than authored.
+//
+// The bindings already carry every fact an approver needs: what the operation does, the route it
+// is, the scope floor behind it, whether it mutates, whether the platform annotated it as
+// destructive, and whether it reads captured telemetry. Deriving the descriptions from those is
+// the same no-drift rule the table itself exists for: a hand-written description per operation
+// would be forty strings that stop matching the surface the day an operation changes, and the
+// place the staleness lands is an approval prompt, which is the worst possible place for it.
+//
+// The description is MARKDOWN rendered to a human, and the argument bag inside it is agent-authored
+// text, so every hole carrying one goes through `fenced` (`../markdown.ts`), which is where that
+// rule and the reason for it live.
+import { resolveConsequence } from '@cat-factory/gatekeeper-bindings';
+import { fenced } from '../markdown.js';
+/** The arguments as an approver should see them: the bag that will actually be forwarded. */
+function renderArguments(args) {
+    const keys = Object.keys(args);
+    if (keys.length === 0)
+        return 'This call carries no arguments.';
+    let payload;
+    try {
+        payload = JSON.stringify(args, null, 2) ?? String(args);
+    }
+    catch {
+        // A cycle or a value JSON cannot carry. The call would fail downstream anyway, and an
+        // approver told nothing about the arguments is being asked to approve an unknown.
+        payload = '"<arguments could not be rendered>"';
+    }
+    return fenced(payload);
+}
+/** The route line both description kinds open their detail with. */
+function routeLine(binding) {
+    return `\`${binding.httpMethod} ${binding.path}\` on ${'`'}${binding.operationId}${'`'}`;
+}
+/**
+ * Describe a read.
+ *
+ * `prohibitAllSharing` is set for exactly the operations the table marks as reading a telemetry
+ * sink, which are the ones that serve CAPTURED TEXT: model prompts and replies, tool arguments,
+ * agent search terms, provisioning output. Every one of those sits inside a `read` key's floor, so
+ * without this the platform's most sensitive reads would be shared onward on the same terms as a
+ * task list. The annotation already exists for the policy layer; this is the second consumer it
+ * was always going to have.
+ */
+export function describeObservation(binding, args, subject) {
+    const captured = binding.telemetrySink !== undefined
+        ? `\n\nThis read serves CAPTURED TEXT from the \`${binding.telemetrySink}\` telemetry sink: ` +
+            'model prompts and replies, tool arguments, or agent search terms. It is withheld from ' +
+            'sharing for that reason.'
+        : '';
+    return {
+        title: `${binding.summary} (${subject.deployment})`,
+        description: `Read ${routeLine(binding)} on the cat-factory deployment at ${subject.deployment}, as ` +
+            `account \`${subject.accountId}\` at policy tier \`${subject.tier}\`.\n\n` +
+            `${renderArguments(args)}${captured}`,
+        ...(binding.telemetrySink !== undefined ? { prohibitAllSharing: true } : {}),
+    };
+}
+/** The stable tag an OS pre-approval rule matches this operation by. */
+export function actionKindOf(binding) {
+    return { tag: binding.name, label: binding.summary };
+}
+/**
+ * Describe a side effect.
+ *
+ * Three fields are fixed for every action this Gatekeeper submits, and each is a statement about
+ * what this implementation does rather than a default:
+ *
+ *   - `implementsRevert: false`. Reverting a started run, a merged pull request or a stopped job is
+ *     not something this Worker can do on the caller's behalf, and the flag exists precisely so the
+ *     UI does not offer an undo that would not work.
+ *   - `awaitDecision: true`. This Gatekeeper does not SIMULATE: there is no provisional run id to
+ *     hand an agent so it can keep working while a human decides. The spec's alternative for a
+ *     non-simulating gatekeeper is to suspend the agent's turn, which is what the flag asks for.
+ *   - `autoApprovable` follows the table's own consequence reading, with the cautious default
+ *     applied by `resolveConsequence`: an unannotated mutation is destructive, so it is NOT
+ *     offered for auto-approval. Being auto-approvable is still only permission for a user who
+ *     opted into this action's kind; it never approves anything by itself.
+ */
+export function describeAction(binding, args, subject) {
+    const consequence = resolveConsequence(binding);
+    const stakes = consequence.destructive
+        ? 'This operation is annotated DESTRUCTIVE: its effects are not safely repeatable, and this ' +
+            'Gatekeeper cannot revert it.'
+        : 'This operation is annotated non-destructive' +
+            (consequence.idempotent ? ' and idempotent.' : '.');
+    return {
+        title: `${binding.summary} (${subject.deployment})`,
+        description: `Call ${routeLine(binding)} on the cat-factory deployment at ${subject.deployment}, as ` +
+            `account \`${subject.accountId}\` at policy tier \`${subject.tier}\`. The call is made with ` +
+            `a per-account API key at scope \`${binding.minScope}\` or above, minted for and stamped ` +
+            'with that account.\n\n' +
+            `${renderArguments(args)}\n\n${stakes}`,
+        implementsRevert: false,
+        awaitDecision: true,
+        autoApprovable: !consequence.destructive,
+        actionKind: actionKindOf(binding),
+    };
+}
+//# sourceMappingURL=descriptions.js.map

package/dist/os/descriptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptions.js","sourceRoot":"","sources":["../../src/os/descriptions.ts"],"names":[],"mappings":"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"}

package/dist/os/discoverability.d.ts

@@ -0,0 +1,30 @@
+/** Why a Cloudflare OS deployment could not finish installing this Gatekeeper. */
+export type DiscoveryBlockerReason = 'missing_exports' | 'no_auto_provisioned_tier';
+/** One thing standing between this Worker and a workspace that could use it. */
+export interface DiscoveryBlocker {
+    reason: DiscoveryBlockerReason;
+    detail: string;
+}
+/**
+ * What `/health` says about the Cloudflare OS door, beside what it says about liveness.
+ *
+ * `discoverable` is derived from `blockers` rather than reported alongside it, so the two cannot
+ * disagree.
+ */
+export interface DiscoverabilityReport {
+    discoverable: boolean;
+    blockers: DiscoveryBlocker[];
+}
+/**
+ * Ask both questions in ONE pass.
+ *
+ * The same rule the binding check follows: an operator who learns the next missing piece only
+ * after redeploying wires a deployment one restart at a time.
+ */
+export declare function describeDiscoverability(deps: {
+    /** The Worker's own exports, as the object model reaches them (`ctx.exports`). */
+    exports: unknown;
+    /** The tier name the policy nominates for auto-provisioned accounts, or `null`. */
+    autoProvisionedTier: string | null;
+}): DiscoverabilityReport;
+//# sourceMappingURL=discoverability.d.ts.map

package/dist/os/discoverability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discoverability.d.ts","sourceRoot":"","sources":["../../src/os/discoverability.ts"],"names":[],"mappings":"AAmBA,kFAAkF;AAClF,MAAM,MAAM,sBAAsB,GAAG,iBAAiB,GAAG,0BAA0B,CAAA;AAEnF,gFAAgF;AAChF,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,sBAAsB,CAAA;IAC9B,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,YAAY,EAAE,OAAO,CAAA;IACrB,QAAQ,EAAE,gBAAgB,EAAE,CAAA;CAC7B;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,kFAAkF;IAClF,OAAO,EAAE,OAAO,CAAA;IAChB,mFAAmF;IACnF,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAA;CACnC,GAAG,qBAAqB,CA0BxB"}

package/dist/os/discoverability.js

@@ -0,0 +1,46 @@
+// Whether a Cloudflare OS deployment could discover and install this Gatekeeper, as a REPORT.
+//
+// Two things have to be true and neither has a request path of its own: the entry module must
+// carry the four exports the object model resolves by name, and the policy must name an
+// `autoProvisionedTier`, since every account this door mints falls to it. A workspace that finds
+// either missing does not get an error anyone monitors; it simply never finishes installing.
+//
+// It is a report rather than a refusal because a Gatekeeper serving `/rpc` and nothing else is a
+// SUPPORTED deployment, not a broken one: the HTTP door is what a consumer that is not a
+// Cloudflare OS speaks, and this package promises to go on serving it. Turning that deployment's
+// liveness red the day it takes a version bump would be this check answering a question nobody
+// asked it, which is the same failure as the health route that reported only the bindings its
+// request path happened to read: a monitor saying something the operator cannot act on.
+//
+// So the two facts are reported side by side, each naming its own remedy, and a deployment that
+// wants discovery keys a monitor on `os.discoverable` while one that does not ignores it.
+import { missingOsExports, OS_EXPORTS } from './exports.js';
+/**
+ * Ask both questions in ONE pass.
+ *
+ * The same rule the binding check follows: an operator who learns the next missing piece only
+ * after redeploying wires a deployment one restart at a time.
+ */
+export function describeDiscoverability(deps) {
+    const blockers = [];
+    const missing = missingOsExports(deps.exports);
+    if (missing.length > 0) {
+        blockers.push({
+            reason: 'missing_exports',
+            detail: `This Worker's entry module does not export ${missing.map((role) => OS_EXPORTS[role]).join(', ')}. ` +
+                'The Cloudflare OS object model resolves each by name against this Worker ' +
+                '(deploy/gatekeeper/src/index.ts is the template).',
+        });
+    }
+    if (deps.autoProvisionedTier === null) {
+        blockers.push({
+            reason: 'no_auto_provisioned_tier',
+            detail: "This deployment's policy names no autoProvisionedTier, so a workspace can discover this " +
+                'Gatekeeper and never open a session through it: an account minted by the object model ' +
+                'carries no identity a grants entry could match, and every one falls to that tier. It is ' +
+                'deliberately separate from defaultTier, which governs the /rpc door.',
+        });
+    }
+    return { discoverable: blockers.length === 0, blockers };
+}
+//# sourceMappingURL=discoverability.js.map

package/dist/os/discoverability.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discoverability.js","sourceRoot":"","sources":["../../src/os/discoverability.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,EAAE;AACF,8FAA8F;AAC9F,wFAAwF;AACxF,iGAAiG;AACjG,6FAA6F;AAC7F,EAAE;AACF,iGAAiG;AACjG,yFAAyF;AACzF,iGAAiG;AACjG,+FAA+F;AAC/F,8FAA8F;AAC9F,wFAAwF;AACxF,EAAE;AACF,gGAAgG;AAChG,0FAA0F;AAE1F,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAsB3D;;;;;GAKG;AACH,MAAM,UAAU,uBAAuB,CAAC,IAKvC;IACC,MAAM,QAAQ,GAAuB,EAAE,CAAA;IAEvC,MAAM,OAAO,GAAG,gBAAgB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IAC9C,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,QAAQ,CAAC,IAAI,CAAC;YACZ,MAAM,EAAE,iBAAiB;YACzB,MAAM,EACJ,8CAA8C,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;gBACpG,2EAA2E;gBAC3E,mDAAmD;SACtD,CAAC,CAAA;IACJ,CAAC;IAED,IAAI,IAAI,CAAC,mBAAmB,KAAK,IAAI,EAAE,CAAC;QACtC,QAAQ,CAAC,IAAI,CAAC;YACZ,MAAM,EAAE,0BAA0B;YAClC,MAAM,EACJ,0FAA0F;gBAC1F,wFAAwF;gBACxF,0FAA0F;gBAC1F,sEAAsE;SACzE,CAAC,CAAA;IACJ,CAAC;IAED,OAAO,EAAE,YAAY,EAAE,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAA;AAC1D,CAAC"}

package/dist/os/exports.d.ts

@@ -0,0 +1,28 @@
+/** The export names the OS object model resolves, keyed by the role each plays. */
+export declare const OS_EXPORTS: {
+    /** The entrypoint a `GATEKEEPER_CAT_FACTORY` service binding targets. Pinned by the OS. */
+    readonly vendor: 'GatekeeperVendor';
+    /** One connected account: what `createAccount()` hands back for the workspace to persist. */
+    readonly account: 'CatFactoryAccount';
+    /** The per-resource Durable Object a bound workspace's session comes from. */
+    readonly resource: 'CatFactoryResource';
+    /**
+     * The bearer-of-identity another vendor's gatekeeper is handed when this account is added as an
+     * observer there. It is a separate export because it must carry NO authority: handing over the
+     * account itself would hand over `revoke()` and the resource classes with it.
+     */
+    readonly verifier: 'CatFactoryVerifier';
+};
+/** A role in the object model, spelled as {@link OS_EXPORTS} keys it. */
+export type OsExportRole = keyof typeof OS_EXPORTS;
+/**
+ * Resolve one of this Worker's own exports, imbued with the props it should carry.
+ *
+ * The cast is the boundary between "what wrangler resolved" and "what this package needs", and the
+ * refusal below is what makes it safe: an export the deployment did not write is named here rather
+ * than reaching a caller as a missing method on a stub.
+ */
+export declare function loopbackExport<T>(exports: unknown, role: OsExportRole, props: unknown): T;
+/** Every export role the OS object model needs that this Worker does not carry. */
+export declare function missingOsExports(exports: unknown): OsExportRole[];
+//# sourceMappingURL=exports.d.ts.map

package/dist/os/exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exports.d.ts","sourceRoot":"","sources":["../../src/os/exports.ts"],"names":[],"mappings":"AAkBA,mFAAmF;AACnF,eAAO,MAAM,UAAU;IACrB,2FAA2F;qBACnF,kBAAkB;IAC1B,6FAA6F;sBACpF,mBAAmB;IAC5B,8EAA8E;uBACpE,oBAAoB;IAC9B;;;;OAIG;uBACO,oBAAoB;CACW,CAAA;AAE3C,yEAAyE;AACzE,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,UAAU,CAAA;AAmBlD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO,GAAG,CAAC,CAYzF;AAED,mFAAmF;AACnF,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,YAAY,EAAE,CAGjE"}

package/dist/os/exports.js

@@ -0,0 +1,68 @@
+// The named exports the OS object model reaches through, and the one place they are stated.
+//
+// A Worker's own entrypoints and Durable Object classes are reachable at runtime as
+// `ctx.exports.<Name>`, resolved against the DEPLOYMENT's entry module rather than this package's.
+// So the base cannot hold the names: it can only agree with the template about them, and this is
+// the file that agreement lives in. Both `deploy/gatekeeper/src/index.ts` and the suite's
+// `test/worker.ts` export exactly these, which is the same "the template's entry point and the
+// suite's are the same lines" check the base/template split already leans on.
+//
+// `GATEKEEPER_VENDOR` is additionally the name the OS itself pins: a `GATEKEEPER_*` service binding
+// targets a `WorkerEntrypoint` export called `GatekeeperVendor`, so that one is not ours to choose.
+//
+// A missing export is REFUSED by name rather than surfacing as `undefined is not a function`
+// several calls later, and `/health` asks about all of them in one pass, so an operator wiring a
+// deployment learns every missing line at once rather than one redeploy at a time.
+import { GatekeeperError } from '../errors.js';
+/** The export names the OS object model resolves, keyed by the role each plays. */
+export const OS_EXPORTS = {
+    /** The entrypoint a `GATEKEEPER_CAT_FACTORY` service binding targets. Pinned by the OS. */
+    vendor: 'GatekeeperVendor',
+    /** One connected account: what `createAccount()` hands back for the workspace to persist. */
+    account: 'CatFactoryAccount',
+    /** The per-resource Durable Object a bound workspace's session comes from. */
+    resource: 'CatFactoryResource',
+    /**
+     * The bearer-of-identity another vendor's gatekeeper is handed when this account is added as an
+     * observer there. It is a separate export because it must carry NO authority: handing over the
+     * account itself would hand over `revoke()` and the resource classes with it.
+     */
+    verifier: 'CatFactoryVerifier',
+};
+/**
+ * Read one factory out of a bag that may not be one.
+ *
+ * Total against an ABSENT bag as well as an incomplete one, because the two are the same fact here
+ * (nothing is reachable) and only one of them would otherwise be reported: a caller with no
+ * `ctx.exports` at all would get a `TypeError` from the read rather than the refusal that names
+ * what is missing, which is the failure this whole module exists to turn into a sentence.
+ */
+function factoryFor(exports, name) {
+    if (typeof exports !== 'object' || exports === null)
+        return undefined;
+    const factory = exports[name];
+    return typeof factory === 'function' ? factory : undefined;
+}
+/**
+ * Resolve one of this Worker's own exports, imbued with the props it should carry.
+ *
+ * The cast is the boundary between "what wrangler resolved" and "what this package needs", and the
+ * refusal below is what makes it safe: an export the deployment did not write is named here rather
+ * than reaching a caller as a missing method on a stub.
+ */
+export function loopbackExport(exports, role, props) {
+    const name = OS_EXPORTS[role];
+    const factory = factoryFor(exports, name);
+    if (factory === undefined) {
+        throw new GatekeeperError('missing_export', `This Worker's entry module does not export '${name}'. The Cloudflare OS object model ` +
+            `reaches it as ctx.exports.${name}; add it to your entry module (deploy/gatekeeper/src/` +
+            'index.ts is the template) and redeploy.');
+    }
+    return factory({ props });
+}
+/** Every export role the OS object model needs that this Worker does not carry. */
+export function missingOsExports(exports) {
+    const roles = Object.keys(OS_EXPORTS);
+    return roles.filter((role) => factoryFor(exports, OS_EXPORTS[role]) === undefined);
+}
+//# sourceMappingURL=exports.js.map

package/dist/os/exports.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exports.js","sourceRoot":"","sources":["../../src/os/exports.ts"],"names":[],"mappings":"AAAA,4FAA4F;AAC5F,EAAE;AACF,oFAAoF;AACpF,mGAAmG;AACnG,iGAAiG;AACjG,0FAA0F;AAC1F,+FAA+F;AAC/F,8EAA8E;AAC9E,EAAE;AACF,oGAAoG;AACpG,oGAAoG;AACpG,EAAE;AACF,6FAA6F;AAC7F,iGAAiG;AACjG,mFAAmF;AAEnF,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAE9C,mFAAmF;AACnF,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,2FAA2F;IAC3F,MAAM,EAAE,kBAAkB;IAC1B,6FAA6F;IAC7F,OAAO,EAAE,mBAAmB;IAC5B,8EAA8E;IAC9E,QAAQ,EAAE,oBAAoB;IAC9B;;;;OAIG;IACH,QAAQ,EAAE,oBAAoB;CACW,CAAA;AAQ3C;;;;;;;GAOG;AACH,SAAS,UAAU,CAAC,OAAgB,EAAE,IAAY;IAChD,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,SAAS,CAAA;IACrE,MAAM,OAAO,GAAI,OAA2B,CAAC,IAAI,CAAC,CAAA;IAClD,OAAO,OAAO,OAAO,KAAK,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAA;AAC5D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAI,OAAgB,EAAE,IAAkB,EAAE,KAAc;IACpF,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,CAAA;IAC7B,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,CAAA;IACzC,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,MAAM,IAAI,eAAe,CACvB,gBAAgB,EAChB,+CAA+C,IAAI,oCAAoC;YACrF,6BAA6B,IAAI,uDAAuD;YACxF,yCAAyC,CAC5C,CAAA;IACH,CAAC;IACD,OAAO,OAAO,CAAC,EAAE,KAAK,EAAE,CAAM,CAAA;AAChC,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,gBAAgB,CAAC,OAAgB;IAC/C,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,UAAU,CAAmB,CAAA;IACvD,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC,KAAK,SAAS,CAAC,CAAA;AACpF,CAAC"}