@noodleseed/one 0.140.0 → 0.141.1

package/node_modules/@noodle-borg/compute/dist/worker-pool.js

@@ -0,0 +1,262 @@
+import { availableParallelism } from 'node:os';
+import { Worker } from 'node:worker_threads';
+import { ComputeError, } from './engine.js';
+const DEFAULT_TERMINATE_GRACE_MS = 500;
+/** Recycle a worker after this many runs to bound WASM heap growth in the shared modules. */
+const WORKER_RECYCLE_AFTER_RUNS = 128;
+function defaultMaxWorkers() {
+    return Math.min(4, Math.max(2, availableParallelism() - 1));
+}
+export class ComputeWorkerPool {
+    #maxWorkers;
+    #terminateGraceMs;
+    #slots = [];
+    #queue = [];
+    #nextRunId = 0;
+    #closed = false;
+    constructor(options = {}) {
+        this.#maxWorkers = Math.max(1, options.maxWorkers ?? defaultMaxWorkers());
+        this.#terminateGraceMs = Math.max(0, options.terminateGraceMs ?? DEFAULT_TERMINATE_GRACE_MS);
+    }
+    /** Run one sandboxed invocation; resolves with the parsed JSON output. */
+    execute(job) {
+        return new Promise((resolve, reject) => {
+            if (this.#closed) {
+                reject(new ComputeError('runtime_error', 'compute engine closed'));
+                return;
+            }
+            const enqueuedAt = Date.now();
+            const idle = this.#slots.find((slot) => slot.active === null && !slot.dropped);
+            if (idle !== undefined) {
+                this.#dispatch(idle, job, enqueuedAt, resolve, reject);
+                return;
+            }
+            if (this.#slots.length < this.#maxWorkers) {
+                this.#dispatch(this.#spawn(), job, enqueuedAt, resolve, reject);
+                return;
+            }
+            const entry = {
+                job,
+                enqueuedAt,
+                expiry: setTimeout(() => this.#expireQueued(entry), job.limits.timeoutMs),
+                resolve,
+                reject,
+            };
+            this.#queue.push(entry);
+        });
+    }
+    /** Reject queued and in-flight work and terminate every worker. */
+    async close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        for (const entry of this.#queue.splice(0)) {
+            clearTimeout(entry.expiry);
+            reportTimings(entry.job, Date.now() - entry.enqueuedAt, 0);
+            entry.reject(new ComputeError('runtime_error', 'compute engine closed'));
+        }
+        const slots = this.#slots.splice(0);
+        for (const slot of slots) {
+            slot.dropped = true;
+            const active = slot.active;
+            if (active !== null && !active.settled) {
+                active.settled = true;
+                clearTimeout(active.backstop);
+                reportTimings(active.job, active.queueWaitMs, Date.now() - active.startedAt);
+                active.reject(new ComputeError('runtime_error', 'compute engine closed'));
+            }
+        }
+        await Promise.all(slots.map((slot) => slot.worker.terminate().catch(() => undefined)));
+    }
+    #spawn() {
+        const worker = new Worker(new URL('./worker-entry.js', import.meta.url), {
+            workerData: { noodleComputeWorker: true },
+        });
+        const slot = { worker, runs: 0, active: null, dropped: false };
+        worker.unref();
+        worker.on('message', (message) => this.#onMessage(slot, message));
+        worker.on('error', () => this.#onWorkerLost(slot));
+        worker.on('exit', () => this.#onWorkerLost(slot));
+        this.#slots.push(slot);
+        return slot;
+    }
+    #dispatch(slot, job, enqueuedAt, resolve, reject) {
+        const startedAt = Date.now();
+        const queueWaitMs = Math.max(0, startedAt - enqueuedAt);
+        const remainingMs = Math.max(1, job.limits.timeoutMs - queueWaitMs);
+        const id = this.#nextRunId;
+        this.#nextRunId += 1;
+        const active = {
+            id,
+            job,
+            queueWaitMs,
+            startedAt,
+            backstop: setTimeout(() => this.#onDeadline(slot, active), remainingMs + this.#terminateGraceMs),
+            settled: false,
+            resolve,
+            reject,
+        };
+        slot.active = active;
+        const message = {
+            t: 'run',
+            id,
+            source: job.source,
+            inputJson: job.inputJson,
+            limits: { ...job.limits, timeoutMs: remainingMs },
+            hostEnabled: job.host !== undefined,
+            consoleEnabled: job.consoleEnabled,
+        };
+        slot.worker.postMessage(message);
+    }
+    #onMessage(slot, message) {
+        const active = slot.active;
+        if (active === null || active.settled || active.id !== message.id)
+            return;
+        if (message.t === 'result') {
+            active.settled = true;
+            clearTimeout(active.backstop);
+            slot.active = null;
+            reportTimings(active.job, active.queueWaitMs, Date.now() - active.startedAt);
+            if (message.outcome.ok) {
+                active.resolve(JSON.parse(message.outcome.outputJson));
+            }
+            else {
+                const { code, message: text, path } = message.outcome.error;
+                active.reject(new ComputeError(code, text, path));
+            }
+            this.#release(slot);
+            return;
+        }
+        if (message.t === 'host_call') {
+            const host = active.job.host;
+            const respond = (envelopeJson) => {
+                if (slot.active === active && !active.settled && !slot.dropped) {
+                    const reply = {
+                        t: 'host_result',
+                        callId: message.callId,
+                        envelopeJson,
+                    };
+                    slot.worker.postMessage(reply);
+                }
+            };
+            if (host === undefined) {
+                respond(JSON.stringify({
+                    ok: false,
+                    error: { code: 'host_call_failed', message: 'host call unavailable' },
+                }));
+                return;
+            }
+            host
+                .callOperation(message.name, message.argsJson)
+                .then(respond)
+                .catch(() => respond(JSON.stringify({
+                ok: false,
+                error: { code: 'host_call_failed', message: 'host call failed' },
+            })));
+            return;
+        }
+        // 'log': deliver to the sink (fire-and-forget failures) and always release the sandbox.
+        const ack = () => {
+            if (slot.active === active && !active.settled && !slot.dropped) {
+                const reply = { t: 'log_done', callId: message.callId };
+                slot.worker.postMessage(reply);
+            }
+        };
+        const sink = active.job.host?.log;
+        if (sink === undefined) {
+            ack();
+            return;
+        }
+        Promise.resolve()
+            .then(() => sink(message.entry))
+            .catch(() => undefined)
+            .then(ack);
+    }
+    /** The queued call's total budget expired before a worker freed: fail fast, stably classified. */
+    #expireQueued(entry) {
+        const index = this.#queue.indexOf(entry);
+        if (index === -1)
+            return;
+        this.#queue.splice(index, 1);
+        reportTimings(entry.job, Date.now() - entry.enqueuedAt, 0);
+        entry.reject(new ComputeError('queue_timeout', 'compute queue wait exhausted the call time budget'));
+    }
+    /** The execution deadline (plus grace) passed without a result: terminate and replace the worker. */
+    #onDeadline(slot, active) {
+        if (active.settled || slot.active !== active)
+            return;
+        active.settled = true;
+        slot.active = null;
+        reportTimings(active.job, active.queueWaitMs, Date.now() - active.startedAt);
+        active.reject(new ComputeError('timeout', 'compute exceeded its time budget'));
+        this.#drop(slot);
+        this.#pumpQueue();
+    }
+    #onWorkerLost(slot) {
+        if (slot.dropped)
+            return;
+        const active = slot.active;
+        if (active !== null && !active.settled) {
+            active.settled = true;
+            clearTimeout(active.backstop);
+            slot.active = null;
+            reportTimings(active.job, active.queueWaitMs, Date.now() - active.startedAt);
+            active.reject(new ComputeError('runtime_error', 'compute worker exited unexpectedly'));
+        }
+        this.#drop(slot);
+        this.#pumpQueue();
+    }
+    #release(slot) {
+        slot.runs += 1;
+        if (slot.runs >= WORKER_RECYCLE_AFTER_RUNS) {
+            this.#drop(slot);
+        }
+        this.#pumpQueue();
+    }
+    #drop(slot) {
+        if (slot.dropped)
+            return;
+        slot.dropped = true;
+        const index = this.#slots.indexOf(slot);
+        if (index !== -1)
+            this.#slots.splice(index, 1);
+        void slot.worker.terminate().catch(() => undefined);
+    }
+    #pumpQueue() {
+        while (this.#queue.length > 0) {
+            const slot = this.#slots.find((candidate) => candidate.active === null && !candidate.dropped) ??
+                (this.#slots.length < this.#maxWorkers ? this.#spawn() : undefined);
+            if (slot === undefined)
+                return;
+            const entry = this.#queue.shift();
+            clearTimeout(entry.expiry);
+            // A slot can free in the same tick the expiry timer is due; keep the classification stable
+            // by expiring an already-exhausted budget here instead of dispatching with the 1ms floor.
+            if (Date.now() - entry.enqueuedAt >= entry.job.limits.timeoutMs) {
+                reportTimings(entry.job, Date.now() - entry.enqueuedAt, 0);
+                entry.reject(new ComputeError('queue_timeout', 'compute queue wait exhausted the call time budget'));
+                continue;
+            }
+            this.#dispatch(slot, entry.job, entry.enqueuedAt, entry.resolve, entry.reject);
+        }
+    }
+}
+function reportTimings(job, queueWaitMs, executionMs) {
+    try {
+        job.onTimings?.({ queueWaitMs, executionMs });
+    }
+    catch {
+        // A telemetry callback must never break the invocation path.
+    }
+}
+let shared;
+/**
+ * The process-wide default pool. Engines share it so many per-deployment engines on one service
+ * instance stay within one bounded worker set; a private pool exists only when an engine is
+ * constructed with explicit options (tests, dedicated capacity).
+ */
+export function sharedComputeWorkerPool() {
+    shared ??= new ComputeWorkerPool();
+    return shared;
+}
+//# sourceMappingURL=worker-pool.js.map

package/node_modules/@noodle-borg/{service/dist/auth/deploy-gate.d.ts → control-plane/dist/deploy-gates.d.ts}

@@ -1,7 +1,11 @@
 import type { IncomingMessage } from 'node:http';
-import { type ControlPlaneAuthResult, type DeployAuthGate } from '@noodle-borg/control-plane/portable';
 import { type PlatformPrincipalResolver } from '@noodle-borg/module';
-export { allowAllGate, bearerToken, type ControlPlaneAuthResult, type ControlPlaneIdentity, type DeployAuthGate, } from '@noodle-borg/control-plane/portable';
+import { type ControlPlaneAuthResult, type DeployAuthGate } from './deploy-auth.js';
+/**
+ * The concrete control-plane gates (moved verbatim from `packages/service/src/auth/deploy-gate.ts`).
+ * Token verification is always injected — the Google `google-auth-library` verifier stays in the
+ * hosted service's composition so this package carries no vendor SDK.
+ */
 export interface GoogleIdTokenVerifier {
     verify(token: string, audience: string | readonly string[]): Promise<{
         subject: string;
@@ -29,7 +33,7 @@ export interface GoogleControlPlaneGateOptions {
     readonly signupAuthorizer?: SignupAuthorizer;
     readonly deniedSignupDomains?: readonly string[];
     readonly deniedSignupSubjects?: readonly string[];
-    readonly verifier?: GoogleIdTokenVerifier;
+    readonly verifier: GoogleIdTokenVerifier;
     /** Optional durable canonical-human resolver. Unset preserves direct-Google compatibility. */
     readonly platformPrincipalResolver?: PlatformPrincipalResolver;
 }
@@ -44,7 +48,7 @@ export interface GoogleWorkloadControlPlaneGateOptions {
     /** Exact immutable Google `sub` values; email is never an authorization key. */
     readonly subjects: readonly string[];
     readonly admins: readonly string[];
-    readonly verifier?: GoogleIdTokenVerifier;
+    readonly verifier: GoogleIdTokenVerifier;
 }
 /**
  * Separate workload gate retained after direct human Google auth is removed. It deliberately bypasses
@@ -59,7 +63,7 @@ export declare class GoogleWorkloadControlPlaneGate implements DeployAuthGate {
 /**
  * Tries several control-plane gates in order and accepts the first that authorizes. On the hosted control
  * plane a first-party caller may present EITHER an AS-issued token (MCP clients, CLI) OR a Google ID token
- * from a trusted audience (the console, [ADR 0116](../../../../docs/decisions/0116-host-the-developer-console.md)) —
+ * from a trusted audience (the console, [ADR 0116](../../../docs/decisions/0116-host-the-developer-console.md)) —
  * restoring the ADR 0039 Google control-plane path alongside the self-hosted AS (ADR 0042). A `403`
  * (identity verified but denied) is definitive and short-circuits; a `401` (couldn't verify this token) falls
  * through to the next gate, so each verifier gets a chance at a token it doesn't recognize.
@@ -93,4 +97,4 @@ export declare class NoodleOAuthControlPlaneGate implements DeployAuthGate {
     constructor(options: NoodleOAuthControlPlaneGateOptions);
     authorize(req: IncomingMessage): Promise<ControlPlaneAuthResult>;
 }
-//# sourceMappingURL=deploy-gate.d.ts.map
+//# sourceMappingURL=deploy-gates.d.ts.map

package/node_modules/@noodle-borg/control-plane/dist/deploy-gates.js

@@ -0,0 +1,266 @@
+import { PlatformIdentityError } from '@noodle-borg/module';
+import { bearerToken } from './deploy-auth.js';
+export class GoogleControlPlaneGate {
+    #audience;
+    #admins;
+    #allowedEmailDomain;
+    #signupMode;
+    #signupAuthorizer;
+    #deniedDomains;
+    #deniedSubjects;
+    #verifier;
+    #platformPrincipalResolver;
+    constructor(options) {
+        const audiences = typeof options.audience === 'string' ? [options.audience] : options.audience;
+        if (audiences.length === 0 || audiences.some((value) => value.length === 0)) {
+            throw new Error('Google audience must be non-empty');
+        }
+        // Preserve the configured shape: a lone string stays a string (byte-for-byte unchanged single-audience
+        // behavior), a list stays a list. google-auth-library accepts either and matches a token's `aud`.
+        this.#audience = options.audience;
+        this.#admins = new Set(options.admins.map((value) => value.toLowerCase()));
+        this.#allowedEmailDomain = normalizeEmailDomain(options.allowedEmailDomain ?? '@noodleseed.com');
+        this.#signupMode = options.signupMode ?? 'restricted';
+        this.#signupAuthorizer = options.signupAuthorizer;
+        this.#deniedDomains = normalizedDomains(options.deniedSignupDomains ?? []);
+        this.#deniedSubjects = new Set(options.deniedSignupSubjects?.map((s) => s.toLowerCase()) ?? []);
+        this.#verifier = options.verifier;
+        this.#platformPrincipalResolver = options.platformPrincipalResolver;
+    }
+    async authorize(req) {
+        const token = bearerToken(req);
+        if (token === null)
+            return { ok: false, status: 401, message: 'missing bearer token' };
+        let identity;
+        try {
+            identity = await this.#verifier.verify(token, this.#audience);
+        }
+        catch {
+            return { ok: false, status: 401, message: 'invalid bearer token' };
+        }
+        const email = identity.email.toLowerCase();
+        if (isDenied(identity.subject, email, this.#deniedSubjects, this.#deniedDomains)) {
+            return { ok: false, status: 403, message: 'signup is denied' };
+        }
+        if (this.#signupMode === 'restricted' &&
+            !email.endsWith(this.#allowedEmailDomain) &&
+            !(await this.#signupAuthorizer?.isSignupAllowed({ subject: identity.subject, email }))) {
+            return { ok: false, status: 403, message: 'email domain is not allowed' };
+        }
+        let identityIssuer;
+        if (this.#platformPrincipalResolver !== undefined) {
+            try {
+                const resolved = await this.#platformPrincipalResolver.resolve({
+                    provider: 'google',
+                    realm: 'accounts.google.com',
+                    subject: identity.subject,
+                    email,
+                    emailVerified: true,
+                });
+                // Google backfill uses its exact existing sub. A resolver that ever violates this would alter the
+                // wire-compatible subject boundary, so fail closed rather than accepting an unsafe mapping.
+                if (resolved.subject !== identity.subject) {
+                    return { ok: false, status: 403, message: 'platform identity is not permitted' };
+                }
+                identityIssuer = resolved.identityIssuer;
+            }
+            catch (error) {
+                if (error instanceof PlatformIdentityError && error.code === 'principal_suspended') {
+                    return { ok: false, status: 403, message: 'platform identity is suspended' };
+                }
+                return { ok: false, status: 403, message: 'platform identity is not permitted' };
+            }
+        }
+        return {
+            ok: true,
+            identity: {
+                subject: identity.subject,
+                email,
+                ...(identityIssuer === undefined ? {} : { identityIssuer }),
+                ...(identity.givenName !== undefined ? { givenName: identity.givenName } : {}),
+                superAdmin: this.#admins.has(identity.subject.toLowerCase()) || this.#admins.has(email),
+            },
+        };
+    }
+}
+/**
+ * Separate workload gate retained after direct human Google auth is removed. It deliberately bypasses
+ * principal creation/email evidence: a workload is not a platform human and may act only when its exact
+ * Google subject and configured audience both match.
+ */
+export class GoogleWorkloadControlPlaneGate {
+    #audience;
+    #subjects;
+    #admins;
+    #verifier;
+    constructor(options) {
+        const audiences = typeof options.audience === 'string' ? [options.audience] : options.audience;
+        if (audiences.length === 0 || audiences.some((audience) => audience.trim().length === 0)) {
+            throw new Error('Google workload audience must be non-empty');
+        }
+        if (options.subjects.length === 0 ||
+            options.subjects.some((subject) => subject.length === 0 ||
+                subject.length > 512 ||
+                subject.trim() !== subject ||
+                /\s/.test(subject))) {
+            throw new Error('Google workload subject allowlist must contain exact non-empty subjects');
+        }
+        this.#audience = options.audience;
+        this.#subjects = new Set(options.subjects);
+        this.#admins = new Set(options.admins.map((value) => value.toLowerCase()));
+        this.#verifier = options.verifier;
+    }
+    async authorize(req) {
+        const token = bearerToken(req);
+        if (token === null)
+            return { ok: false, status: 401, message: 'missing bearer token' };
+        let identity;
+        try {
+            identity = await this.#verifier.verify(token, this.#audience);
+        }
+        catch {
+            return { ok: false, status: 401, message: 'invalid bearer token' };
+        }
+        const email = identity.email.toLowerCase();
+        if (!this.#subjects.has(identity.subject)) {
+            // A verified service-account token is definitively outside the exact workload allowlist and must not
+            // fall through to the temporary broad human-Google compatibility gate. Ordinary human tokens remain
+            // verifier-not-applicable so the fallback can handle them during the 14-day window.
+            return email.endsWith('.gserviceaccount.com')
+                ? { ok: false, status: 403, message: 'workload identity is not permitted' }
+                : { ok: false, status: 401, message: 'not a configured workload identity' };
+        }
+        return {
+            ok: true,
+            identity: {
+                subject: identity.subject,
+                email,
+                // Workload authority is bound only to the exact immutable Google subject. Email is profile data.
+                superAdmin: this.#admins.has(identity.subject.toLowerCase()),
+            },
+        };
+    }
+}
+/**
+ * Tries several control-plane gates in order and accepts the first that authorizes. On the hosted control
+ * plane a first-party caller may present EITHER an AS-issued token (MCP clients, CLI) OR a Google ID token
+ * from a trusted audience (the console, [ADR 0116](../../../docs/decisions/0116-host-the-developer-console.md)) —
+ * restoring the ADR 0039 Google control-plane path alongside the self-hosted AS (ADR 0042). A `403`
+ * (identity verified but denied) is definitive and short-circuits; a `401` (couldn't verify this token) falls
+ * through to the next gate, so each verifier gets a chance at a token it doesn't recognize.
+ */
+export class CompositeControlPlaneGate {
+    #gates;
+    constructor(gates) {
+        if (gates.length === 0) {
+            throw new Error('composite control-plane gate requires at least one gate');
+        }
+        this.#gates = gates;
+    }
+    async authorize(req) {
+        let last = { ok: false, status: 401, message: 'invalid bearer token' };
+        for (const gate of this.#gates) {
+            const result = await gate.authorize(req);
+            if (result.ok)
+                return result;
+            // 403 = identity verified but denied (domain/deny-list): definitive, do not try another verifier.
+            if (result.status === 403)
+                return result;
+            last = result;
+        }
+        return last;
+    }
+}
+export class NoodleOAuthControlPlaneGate {
+    #verifier;
+    #audiences;
+    #admins;
+    #allowedEmailDomain;
+    #signupMode;
+    #signupAuthorizer;
+    #deniedDomains;
+    #deniedSubjects;
+    #platformPrincipalResolver;
+    constructor(options) {
+        const audiences = typeof options.audience === 'string' ? [options.audience] : options.audience;
+        if (audiences.length === 0 || audiences.some((audience) => audience.length === 0)) {
+            throw new Error('OAuth audience must be non-empty');
+        }
+        this.#verifier = options.verifier;
+        this.#audiences = [...audiences];
+        this.#admins = new Set(options.admins.map((value) => value.toLowerCase()));
+        this.#allowedEmailDomain = normalizeEmailDomain(options.allowedEmailDomain ?? '@noodleseed.com');
+        this.#signupMode = options.signupMode ?? 'restricted';
+        this.#signupAuthorizer = options.signupAuthorizer;
+        this.#deniedDomains = normalizedDomains(options.deniedSignupDomains ?? []);
+        this.#deniedSubjects = new Set(options.deniedSignupSubjects?.map((s) => s.toLowerCase()) ?? []);
+        this.#platformPrincipalResolver = options.platformPrincipalResolver;
+    }
+    async authorize(req) {
+        const token = bearerToken(req);
+        if (token === null)
+            return { ok: false, status: 401, message: 'missing bearer token' };
+        let identity = null;
+        for (const audience of this.#audiences) {
+            identity = await this.#verifier(token, audience);
+            if (identity !== null)
+                break;
+        }
+        if (!identity?.email) {
+            return { ok: false, status: 401, message: 'invalid bearer token' };
+        }
+        const email = identity.email.toLowerCase();
+        if (isDenied(identity.subject, email, this.#deniedSubjects, this.#deniedDomains)) {
+            return { ok: false, status: 403, message: 'signup is denied' };
+        }
+        if (this.#signupMode === 'restricted' &&
+            !email.endsWith(this.#allowedEmailDomain) &&
+            !(await this.#signupAuthorizer?.isSignupAllowed({ subject: identity.subject, email }))) {
+            return { ok: false, status: 403, message: 'email domain is not allowed' };
+        }
+        let identityIssuer;
+        if (this.#platformPrincipalResolver !== undefined) {
+            try {
+                // A Noodle token already has a canonical subject. Do not create an identity from a mutable email claim.
+                identityIssuer = (await this.#platformPrincipalResolver.resolveExisting(identity.subject))
+                    ?.identityIssuer;
+            }
+            catch (error) {
+                if (error instanceof PlatformIdentityError && error.code === 'principal_suspended') {
+                    return { ok: false, status: 403, message: 'platform identity is suspended' };
+                }
+                return { ok: false, status: 403, message: 'platform identity is not permitted' };
+            }
+        }
+        return {
+            ok: true,
+            identity: {
+                subject: identity.subject,
+                email,
+                ...(identityIssuer === undefined ? {} : { identityIssuer }),
+                ...(identity.givenName !== undefined ? { givenName: identity.givenName } : {}),
+                ...(identity.developerGrantId !== undefined
+                    ? { developerGrantId: identity.developerGrantId }
+                    : {}),
+                ...(identity.oauthClientId !== undefined ? { oauthClientId: identity.oauthClientId } : {}),
+                ...(identity.authTime !== undefined ? { authTime: identity.authTime } : {}),
+                superAdmin: identity.developerGrantId === undefined &&
+                    // Noodle access tokens carry the canonical principal. Mutable email must never grant authority.
+                    this.#admins.has(identity.subject.toLowerCase()),
+            },
+        };
+    }
+}
+function normalizeEmailDomain(value) {
+    const domain = value.trim().toLowerCase();
+    if (domain.length === 0)
+        throw new Error('allowed email domain must be non-empty');
+    return domain.startsWith('@') ? domain : `@${domain}`;
+}
+function normalizedDomains(values) {
+    return new Set(values.map(normalizeEmailDomain));
+}
+function isDenied(subject, email, deniedSubjects, deniedDomains) {
+    return (deniedSubjects.has(subject.toLowerCase()) || [...deniedDomains].some((d) => email.endsWith(d)));
+}
+//# sourceMappingURL=deploy-gates.js.map

package/node_modules/@noodle-borg/control-plane/dist/portable.d.ts

@@ -1,5 +1,6 @@
 export type { ActiveMcpSubdomainClaim, ChangeMcpSubdomainInput, ControlPlaneIdentity, CreateOrgWithOwnerInput, McpSubdomainMutationResult, McpSubdomainSetting, OrganizationStore, OrgDomainRecord, OrgInvitationRecord, OrgMemberRecord, OrgOpenAIAppsChallengeRecord, OrgRecord, OrgRole, PersonalWorkspaceProvisionInput, PersonalWorkspaceProvisionResult, SignupAllowlistKind, SignupAllowlistRecord, WelcomeEmailRecord, } from './contracts.js';
 export { allowAllGate, bearerToken, type ControlPlaneAuthResult, type DeployAuthGate, } from './deploy-auth.js';
+export { CompositeControlPlaneGate, type ControlPlaneSignupMode, GoogleControlPlaneGate, type GoogleControlPlaneGateOptions, type GoogleIdTokenVerifier, GoogleWorkloadControlPlaneGate, type GoogleWorkloadControlPlaneGateOptions, NoodleOAuthControlPlaneGate, type NoodleOAuthControlPlaneGateOptions, type SignupAuthorizer, } from './deploy-gates.js';
 export { InMemoryControlPlaneStore } from './in-memory-control-plane-store.js';
 export { bindInMemoryOrganizationStore, type InMemoryOrganizationOperations, InMemoryOrganizationStore, } from './in-memory-organization-store.js';
 export { InMemoryMcpSubdomainClaimStore, McpSubdomainCooldownError, McpSubdomainIdempotencyConflictError, McpSubdomainOwnerRequiredError, type McpSubdomainRouteRef, McpSubdomainUnavailableError, mcpSubdomainEndpointOptions, type ResolvedMcpTenantRef, resolveMcpSubdomainTenant, } from './mcp-subdomain-claims.js';

package/node_modules/@noodle-borg/control-plane/dist/portable.js

@@ -1,4 +1,5 @@
 export { allowAllGate, bearerToken, } from './deploy-auth.js';
+export { CompositeControlPlaneGate, GoogleControlPlaneGate, GoogleWorkloadControlPlaneGate, NoodleOAuthControlPlaneGate, } from './deploy-gates.js';
 export { InMemoryControlPlaneStore } from './in-memory-control-plane-store.js';
 export { bindInMemoryOrganizationStore, InMemoryOrganizationStore, } from './in-memory-organization-store.js';
 export { InMemoryMcpSubdomainClaimStore, McpSubdomainCooldownError, McpSubdomainIdempotencyConflictError, McpSubdomainOwnerRequiredError, McpSubdomainUnavailableError, mcpSubdomainEndpointOptions, resolveMcpSubdomainTenant, } from './mcp-subdomain-claims.js';

package/node_modules/@noodle-borg/developer-mcp/dist/capabilities.js

@@ -1,5 +1,6 @@
 export const DEVELOPER_MCP_PATH = '/developer/mcp';
 export const DEVELOPER_CLI_PATH = '/developer/cli';
+export const DEVELOPER_ASSISTANT_PATH = '/developer/assistant';
 export const DEVELOPER_CAPABILITIES = [
     'cloud:read',
     'deployments:write',
@@ -19,6 +20,13 @@ const CLI_CAPABILITIES = Object.freeze([
     'deployments:write',
     'config:write',
 ]);
+// The onboarding assistant reads the operator's world and deploys the confirm-gated first app —
+// never rollback and never config: the ceiling is structural, so a token minted through the
+// control-plane exchange can never store those capabilities (ADR 0218).
+const ASSISTANT_CAPABILITIES = Object.freeze([
+    'cloud:read',
+    'deployments:write',
+]);
 export function isDeveloperCapability(value) {
     return typeof value === 'string' && DEVELOPER_CAPABILITY_SET.has(value);
 }
@@ -33,7 +41,7 @@ export function developerResourcePath(resource) {
 }
 export function isDeveloperResource(resource) {
     const path = developerResourcePath(resource);
-    return path === DEVELOPER_MCP_PATH || path === DEVELOPER_CLI_PATH;
+    return (path === DEVELOPER_MCP_PATH || path === DEVELOPER_CLI_PATH || path === DEVELOPER_ASSISTANT_PATH);
 }
 export function capabilitiesForDeveloperResource(resource) {
     const path = developerResourcePath(resource);
@@ -41,6 +49,8 @@ export function capabilitiesForDeveloperResource(resource) {
         return MCP_CAPABILITIES;
     if (path === DEVELOPER_CLI_PATH)
         return CLI_CAPABILITIES;
+    if (path === DEVELOPER_ASSISTANT_PATH)
+        return ASSISTANT_CAPABILITIES;
     return [];
 }
 //# sourceMappingURL=capabilities.js.map

package/node_modules/@noodle-borg/developer-mcp/dist/index.js

@@ -1,4 +1,4 @@
-export { capabilitiesForDeveloperResource, DEVELOPER_CAPABILITIES, DEVELOPER_CLI_PATH, DEVELOPER_MCP_PATH, developerResourcePath, isDeveloperCapability, isDeveloperResource, } from './capabilities.js';
+export { capabilitiesForDeveloperResource, DEVELOPER_ASSISTANT_PATH, DEVELOPER_CAPABILITIES, DEVELOPER_CLI_PATH, DEVELOPER_MCP_PATH, developerResourcePath, isDeveloperCapability, isDeveloperResource, } from './capabilities.js';
 export * from './contracts.js';
 export * from './diagnosis.js';
 export * from './port.js';

package/node_modules/@noodle-borg/module/dist/platform-human-identity.d.ts

@@ -10,7 +10,13 @@ export interface UpstreamHumanIdentity {
 export declare function normalizePlatformIdentityEmail(value: string): string;
 export interface UpstreamAuthorizationOptions {
     readonly forceAuthentication?: boolean;
+    readonly screenHint?: 'sign-up' | 'sign-in';
 }
+export declare const FRESH_AUTH_SCOPE = "noodle:fresh-auth";
+export declare const SIGNUP_INTENT_SCOPE = "noodle:signup-intent";
+export declare function upstreamAuthorizationOptionsInput(scopes: readonly string[] | undefined, signupClient: boolean): {
+    readonly options?: UpstreamAuthorizationOptions;
+};
 export interface UpstreamHumanAuthentication extends UpstreamHumanIdentity {
     readonly locale?: string;
     readonly timeZone?: string;

package/node_modules/@noodle-borg/module/dist/platform-human-identity.js

@@ -6,6 +6,20 @@ export function normalizePlatformIdentityEmail(value) {
     }
     return normalized;
 }
+export const FRESH_AUTH_SCOPE = 'noodle:fresh-auth';
+export const SIGNUP_INTENT_SCOPE = 'noodle:signup-intent';
+export function upstreamAuthorizationOptionsInput(scopes, signupClient) {
+    const forceAuthentication = scopes?.includes(FRESH_AUTH_SCOPE) === true;
+    const signup = signupClient && scopes?.includes(SIGNUP_INTENT_SCOPE) === true;
+    if (!forceAuthentication && !signup)
+        return {};
+    return {
+        options: {
+            ...(forceAuthentication ? { forceAuthentication: true } : {}),
+            ...(signup ? { screenHint: 'sign-up' } : {}),
+        },
+    };
+}
 /** Stable cross-package identity failure used by private providers and public consumers alike. */
 export class PlatformIdentityError extends Error {
     code;