@noodleseed/one 0.162.0 → 0.164.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { type AssistantAccess, type AssistantCapability, type AssistantLabels, type AssistantLayoutMode, type AssistantPosition, type AssistantPresentationOptions, type AssistantPresentationTone, type AssistantSurfaceConfig, type AssistantSurfaceMode, type AssistantThemeMode, type AssistantUiOptions, type AuthenticatedWebsiteAccess, algolia, annotations, asset, authenticatedWebsite, type BoundConnectorRef, type BrandThemeTokens, bind, type CapabilityRef, type ConnectionBinding, type ConnectionRef, type ConnectionSource, type CustomerAuthRouting, type CustomerEndpointClaimMapping, type CustomerEndpointPolicy, type CustomerEndpointRef, clientCredentials, connection, connector, customerAuth, customerEndpoint, type EmbeddedAssistantConfig, type EmbeddedAssistantOptions, embeddedAssistant, externalExchange, file, firecrawl, type GoogleWorkloadIdentityAccess, gmailConnector, googleWorkloadIdentity, handoffSession, knowledge, type ManagedCollectionDeclaration, type ManagedCollectionInput, managedCollection, managedSecret, meilisearch, type NoodleManagedModel, noodleManaged, type OpenAICompatibleModel, type OpenAICompatibleModelInput, openAICompatible, type PublicWebsiteAccess, prompt, publicWebsite, resource, type ServerDefinition, secret, server, site, tavily, tool, variable, when, z, } from '@noodle-borg/authoring';
+export { type AssistantAccess, type AssistantCapability, type AssistantLabels, type AssistantLayoutMode, type AssistantPosition, type AssistantPresentationOptions, type AssistantPresentationTone, type AssistantSurfaceConfig, type AssistantSurfaceMode, type AssistantThemeMode, type AssistantUiOptions, type AuthenticatedWebsiteAccess, algolia, annotations, asset, authenticatedWebsite, type BoundConnectorRef, type BrandThemeTokens, bind, type CapabilityRef, type ConnectionBinding, type ConnectionRef, type ConnectionSource, type CustomerAuthRouting, type CustomerEndpointClaimMapping, type CustomerEndpointPolicy, type CustomerEndpointRef, clientCredentials, connection, connector, customerAuth, customerEndpoint, type EmbeddedAssistantConfig, type EmbeddedAssistantOptions, embeddedAssistant, externalExchange, file, firecrawl, type GoogleWorkloadIdentityAccess, gmailConnector, googleWorkloadIdentity, handoffSession, knowledge, type ManagedCollectionDeclaration, type ManagedCollectionInput, managedCollection, managedSecret, meilisearch, type NoodleManagedModel, noodleManaged, noodlePlatform, type OpenAICompatibleModel, type OpenAICompatibleModelInput, openAICompatible, type PublicWebsiteAccess, prompt, publicWebsite, resource, type ServerDefinition, secret, server, site, tavily, tool, variable, when, z, } from '@noodle-borg/authoring';
 export { run } from './cli.js';
 export { appendServer, type ConfigLocation, clearConfig, configPath, maskToken, type NoodleConfig, readConfig, readServers, resolveAuthToken, resolveServiceUrl, type SavedServer, serversPath, writeConfig, } from './config.js';
 export { DEFAULT_SERVICE_URL, type DeployOptions, type DeployOutcome, deploy } from './deploy.js';

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -1,4 +1,4 @@
-export { algolia, annotations, asset, authenticatedWebsite, bind, clientCredentials, connection, connector, customerAuth, customerEndpoint, embeddedAssistant, externalExchange, file, firecrawl, gmailConnector, googleWorkloadIdentity, handoffSession, knowledge, managedCollection, managedSecret, meilisearch, noodleManaged, openAICompatible, prompt, publicWebsite, resource, secret, server, site, tavily, tool, variable, when, z, } from '@noodle-borg/authoring';
+export { algolia, annotations, asset, authenticatedWebsite, bind, clientCredentials, connection, connector, customerAuth, customerEndpoint, embeddedAssistant, externalExchange, file, firecrawl, gmailConnector, googleWorkloadIdentity, handoffSession, knowledge, managedCollection, managedSecret, meilisearch, noodleManaged, noodlePlatform, openAICompatible, prompt, publicWebsite, resource, secret, server, site, tavily, tool, variable, when, z, } from '@noodle-borg/authoring';
 export { run } from './cli.js';
 export { appendServer, clearConfig, configPath, maskToken, readConfig, readServers, resolveAuthToken, resolveServiceUrl, serversPath, writeConfig, } from './config.js';
 export { DEFAULT_SERVICE_URL, deploy } from './deploy.js';

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAaL,OAAO,EACP,WAAW,EACX,KAAK,EACL,oBAAoB,EAGpB,IAAI,EASJ,iBAAiB,EACjB,UAAU,EACV,SAAS,EACT,YAAY,EACZ,gBAAgB,EAGhB,iBAAiB,EACjB,gBAAgB,EAChB,IAAI,EACJ,SAAS,EAET,cAAc,EACd,sBAAsB,EACtB,cAAc,EACd,SAAS,EAGT,iBAAiB,EACjB,aAAa,EACb,WAAW,EAEX,aAAa,EAGb,gBAAgB,EAEhB,MAAM,EACN,aAAa,EACb,QAAQ,EAER,MAAM,EACN,MAAM,EACN,IAAI,EACJ,MAAM,EACN,IAAI,EACJ,QAAQ,EACR,IAAI,EACJ,CAAC,GACF,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EACL,YAAY,EAEZ,WAAW,EACX,UAAU,EACV,SAAS,EAET,UAAU,EACV,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EAEjB,WAAW,EACX,WAAW,GACZ,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,mBAAmB,EAA0C,MAAM,EAAE,MAAM,aAAa,CAAC;AAClG,OAAO,EAAyD,GAAG,EAAE,MAAM,UAAU,CAAC;AACtF,OAAO,EACL,sBAAsB,EAItB,eAAe,EACf,qBAAqB,EACrB,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,8BAA8B,EAC9B,kBAAkB,EAClB,YAAY,EAOZ,wBAAwB,EACxB,2BAA2B,EAC3B,kBAAkB,GACnB,MAAM,2CAA2C,CAAC;AACnD,OAAO,EACL,yBAAyB,EAEzB,uBAAuB,GACxB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAGL,eAAe,EACf,iBAAiB,GAClB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,wBAAwB,EAGxB,WAAW,EAGX,uBAAuB,EAGvB,iBAAiB,EACjB,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACrB,eAAe,EACf,yBAAyB,EACzB,kBAAkB,EAClB,6BAA6B,EAC7B,uBAAuB,EACvB,sBAAsB,EACtB,wBAAwB,EACxB,sBAAsB,EACtB,gBAAgB,GACjB,MAAM,cAAc,CAAC;AACtB,OAAO,EAIL,QAAQ,GACT,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAaL,OAAO,EACP,WAAW,EACX,KAAK,EACL,oBAAoB,EAGpB,IAAI,EASJ,iBAAiB,EACjB,UAAU,EACV,SAAS,EACT,YAAY,EACZ,gBAAgB,EAGhB,iBAAiB,EACjB,gBAAgB,EAChB,IAAI,EACJ,SAAS,EAET,cAAc,EACd,sBAAsB,EACtB,cAAc,EACd,SAAS,EAGT,iBAAiB,EACjB,aAAa,EACb,WAAW,EAEX,aAAa,EACb,cAAc,EAGd,gBAAgB,EAEhB,MAAM,EACN,aAAa,EACb,QAAQ,EAER,MAAM,EACN,MAAM,EACN,IAAI,EACJ,MAAM,EACN,IAAI,EACJ,QAAQ,EACR,IAAI,EACJ,CAAC,GACF,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EACL,YAAY,EAEZ,WAAW,EACX,UAAU,EACV,SAAS,EAET,UAAU,EACV,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EAEjB,WAAW,EACX,WAAW,GACZ,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,mBAAmB,EAA0C,MAAM,EAAE,MAAM,aAAa,CAAC;AAClG,OAAO,EAAyD,GAAG,EAAE,MAAM,UAAU,CAAC;AACtF,OAAO,EACL,sBAAsB,EAItB,eAAe,EACf,qBAAqB,EACrB,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,8BAA8B,EAC9B,kBAAkB,EAClB,YAAY,EAOZ,wBAAwB,EACxB,2BAA2B,EAC3B,kBAAkB,GACnB,MAAM,2CAA2C,CAAC;AACnD,OAAO,EACL,yBAAyB,EAEzB,uBAAuB,GACxB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAGL,eAAe,EACf,iBAAiB,GAClB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,wBAAwB,EAGxB,WAAW,EAGX,uBAAuB,EAGvB,iBAAiB,EACjB,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACrB,eAAe,EACf,yBAAyB,EACzB,kBAAkB,EAClB,6BAA6B,EAC7B,uBAAuB,EACvB,sBAAsB,EACtB,wBAAwB,EACxB,sBAAsB,EACtB,gBAAgB,GACjB,MAAM,cAAc,CAAC;AACtB,OAAO,EAIL,QAAQ,GACT,MAAM,eAAe,CAAC"}

package/node_modules/@noodle-borg/admission-limits/dist/counter-store.d.ts

@@ -17,7 +17,7 @@ export interface CounterRequest {
      * Which window the ceiling belongs to. Solvency bounds are daily (the default); the per-address
      * fairness tier is hourly, so a visitor's accidental burst forgives itself within the same visit.
      */
-    readonly window?: 'day' | 'hour';
+    readonly window?: 'day' | 'hour' | 'minute';
 }
 export interface CounterOutcome {
     readonly allowed: boolean;
@@ -27,6 +27,17 @@ export interface CounterOutcome {
     /** Start of the window after the one this counter belongs to. */
     readonly resetAt: Date;
 }
+export interface ExhaustedCounter {
+    readonly key: string;
+    readonly limit: number;
+    readonly resetAt: Date;
+}
+export type AtomicCounterAttemptOutcome = {
+    readonly kind: 'consumed' | 'replayed' | 'conflict';
+} | {
+    readonly kind: 'refused';
+    readonly exhausted: readonly ExhaustedCounter[];
+};
 export interface DailyCounterStore {
     /**
      * Atomically consume against a key's daily budget. Must be safe under concurrency: N simultaneous
@@ -64,6 +75,14 @@ export interface DailyCounterStore {
 export interface AtomicDailyCounterStore extends DailyCounterStore {
     /** Atomically consume every request, returning false without changing any row when one refuses. */
     consumeAll(requests: readonly CounterRequest[], now: Date): Promise<boolean>;
+    /**
+     * Consume an atomic batch once for one opaque logical attempt. Equal retries replay without spending;
+     * a changed fingerprint conflicts. Only successful admission creates retry evidence.
+     */
+    consumeAllOnce(requests: readonly CounterRequest[], attempt: {
+        readonly key: string;
+        readonly fingerprint: string;
+    }, now: Date): Promise<AtomicCounterAttemptOutcome>;
 }
 /** Counters roll at UTC midnight — a fixed boundary no tenant timezone can shift. */
 export declare function dayKey(now: Date): string;
@@ -98,5 +117,5 @@ export declare function counterRow(request: Pick<CounterRequest, 'key' | 'window
 export declare const COUNTER_RETENTION_DAYS = 2;
 /** The oldest day still readable at `now`. Rows before it are unreachable and may be deleted. */
 export declare function retentionCutoff(now: Date): string;
-export declare function nextReset(now: Date, window?: 'day' | 'hour'): Date;
+export declare function nextReset(now: Date, window?: 'day' | 'hour' | 'minute'): Date;
 //# sourceMappingURL=counter-store.d.ts.map

package/node_modules/@noodle-borg/admission-limits/dist/counter-store.js

@@ -31,7 +31,11 @@ export function hourKey(now) {
  */
 export function counterRow(request, now) {
     return {
-        key: request.window === 'hour' ? `${request.key}@${hourKey(now)}` : request.key,
+        key: request.window === 'minute'
+            ? `${request.key}@${now.toISOString().slice(0, 16)}`
+            : request.window === 'hour'
+                ? `${request.key}@${hourKey(now)}`
+                : request.key,
         day: dayKey(now),
     };
 }
@@ -49,6 +53,11 @@ export function retentionCutoff(now) {
 }
 export function nextReset(now, window = 'day') {
     const next = new Date(now);
+    if (window === 'minute') {
+        next.setUTCSeconds(0, 0);
+        next.setUTCMinutes(next.getUTCMinutes() + 1);
+        return next;
+    }
     if (window === 'hour') {
         next.setUTCMinutes(0, 0, 0);
         next.setUTCHours(next.getUTCHours() + 1);

package/node_modules/@noodle-borg/admission-limits/dist/in-memory-counter-store.d.ts

@@ -1,4 +1,4 @@
-import { type AtomicDailyCounterStore, type CounterOutcome, type CounterRequest, type DailyCounterStore } from './counter-store.js';
+import { type AtomicCounterAttemptOutcome, type AtomicDailyCounterStore, type CounterOutcome, type CounterRequest, type DailyCounterStore } from './counter-store.js';
 /**
  * Process-local counters for local development and tests.
  *
@@ -11,6 +11,10 @@ export declare class InMemoryDailyCounterStore implements DailyCounterStore, Ato
     readonly durable = false;
     consume(request: CounterRequest, now: Date): Promise<CounterOutcome>;
     consumeAll(requests: readonly CounterRequest[], now: Date): Promise<boolean>;
+    consumeAllOnce(requests: readonly CounterRequest[], attempt: {
+        readonly key: string;
+        readonly fingerprint: string;
+    }, now: Date): Promise<AtomicCounterAttemptOutcome>;
     prune(now: Date): Promise<number>;
     peek(key: string, now: Date): Promise<number>;
 }

package/node_modules/@noodle-borg/admission-limits/dist/in-memory-counter-store.js

@@ -9,6 +9,7 @@ import { counterRow, dayKey, nextReset, retentionCutoff, } from './counter-store
 export class InMemoryDailyCounterStore {
     durable = false;
     #used = new Map();
+    #receipts = new Map();
     async consume(request, now) {
         const row = counterRow(request, now);
         const key = `${row.day}:${row.key}`;
@@ -22,6 +23,21 @@ export class InMemoryDailyCounterStore {
         return { allowed: true, used: used + amount, limit: request.limit, resetAt };
     }
     async consumeAll(requests, now) {
+        return this.#consumeAll(requests, now).length === 0;
+    }
+    async consumeAllOnce(requests, attempt, now) {
+        const receipt = counterRow({ key: attempt.key }, now);
+        const receiptKey = `${receipt.day}:${receipt.key}`;
+        const existing = this.#receipts.get(receiptKey);
+        if (existing !== undefined)
+            return { kind: existing === attempt.fingerprint ? 'replayed' : 'conflict' };
+        const exhausted = this.#consumeAll(requests, now);
+        if (exhausted.length > 0)
+            return { kind: 'refused', exhausted };
+        this.#receipts.set(receiptKey, attempt.fingerprint);
+        return { kind: 'consumed' };
+    }
+    #consumeAll(requests, now) {
         const batch = requests.map((request) => {
             const row = counterRow(request, now);
             return {
@@ -33,15 +49,22 @@ export class InMemoryDailyCounterStore {
         if (new Set(batch.map((entry) => entry.key)).size !== batch.length) {
             throw new Error('atomic counter requests must have distinct row identities');
         }
+        const exhausted = [];
         for (const entry of batch) {
             const used = this.#used.get(entry.key) ?? 0;
             if (entry.request.limit <= 0 || used + entry.amount > entry.request.limit)
-                return false;
+                exhausted.push({
+                    key: entry.request.key,
+                    limit: entry.request.limit,
+                    resetAt: nextReset(now, entry.request.window),
+                });
         }
+        if (exhausted.length > 0)
+            return exhausted;
         for (const entry of batch) {
             this.#used.set(entry.key, (this.#used.get(entry.key) ?? 0) + entry.amount);
         }
-        return true;
+        return [];
     }
     async prune(now) {
         // The day is the map key's prefix, and it sorts lexicographically because it is ISO-8601 — which
@@ -54,6 +77,12 @@ export class InMemoryDailyCounterStore {
                 removed += 1;
             }
         }
+        for (const key of this.#receipts.keys()) {
+            if ((key.split(':')[0] ?? '') < cutoff) {
+                this.#receipts.delete(key);
+                removed += 1;
+            }
+        }
         return removed;
     }
     async peek(key, now) {

package/node_modules/@noodle-borg/admission-limits/dist/portable.d.ts

@@ -3,5 +3,8 @@ export * from './client-address.js';
 export * from './counter-store.js';
 export * from './envelope.js';
 export * from './in-memory-counter-store.js';
+export * from './public-admission-assertion.js';
+export * from './public-record-admission.js';
+export * from './request-attribution.js';
 export * from './visitor-bucket.js';
 //# sourceMappingURL=portable.d.ts.map

package/node_modules/@noodle-borg/admission-limits/dist/portable.js

@@ -3,5 +3,8 @@ export * from './client-address.js';
 export * from './counter-store.js';
 export * from './envelope.js';
 export * from './in-memory-counter-store.js';
+export * from './public-admission-assertion.js';
+export * from './public-record-admission.js';
+export * from './request-attribution.js';
 export * from './visitor-bucket.js';
 //# sourceMappingURL=portable.js.map

package/node_modules/@noodle-borg/admission-limits/dist/public-admission-assertion.d.ts

@@ -0,0 +1,28 @@
+export declare const PUBLIC_ADMISSION_ASSERTION_HEADER = "x-noodle-public-admission";
+export declare const PUBLIC_ADMISSION_ASSERTION_TTL_SECONDS = 60;
+/** A request binding is private BFF-to-service evidence, never a browser credential or tool authority. */
+export interface PublicAdmissionRequestBinding {
+    readonly surfaceId: string;
+    readonly installationId: string;
+    readonly route: string;
+    readonly method: 'POST';
+    readonly idempotencyKey: string;
+    readonly requestDigest: string;
+}
+export interface PublicAdmissionSigningKeys {
+    readonly activeVersion: string;
+    readonly keys: Readonly<Record<string, string>>;
+    /** Separate stable deployment key: rotating assertion signing keys never resets quota buckets. */
+    readonly pseudonymKey: string;
+}
+export declare function publicAdmissionRequestDigest(serializedBody: string): string;
+/** Caller must derive sourceAddress from a verified ingress adapter, never arbitrary forwarding headers. */
+export declare function signPublicAdmissionAssertion(binding: PublicAdmissionRequestBinding, attribution: {
+    readonly sourceAddress: string;
+    readonly visitorHint?: unknown;
+}, keys: PublicAdmissionSigningKeys, now: Date): string;
+export declare function verifyPublicAdmissionAssertion(token: string, expected: PublicAdmissionRequestBinding, keys: PublicAdmissionSigningKeys, now: Date): {
+    readonly network: string;
+    readonly visitor?: string;
+} | undefined;
+//# sourceMappingURL=public-admission-assertion.d.ts.map

package/node_modules/@noodle-borg/admission-limits/dist/public-admission-assertion.js

@@ -0,0 +1,124 @@
+import { createHash, createHmac, timingSafeEqual } from 'node:crypto';
+import { clientAddressBucket } from './client-address.js';
+import { dayKey } from './counter-store.js';
+import { visitorBucket } from './visitor-bucket.js';
+export const PUBLIC_ADMISSION_ASSERTION_HEADER = 'x-noodle-public-admission';
+export const PUBLIC_ADMISSION_ASSERTION_TTL_SECONDS = 60;
+const CLOCK_SKEW_SECONDS = 5;
+const digestPattern = /^[a-f0-9]{64}$/;
+export function publicAdmissionRequestDigest(serializedBody) {
+    return createHash('sha256').update(serializedBody).digest('hex');
+}
+/** Caller must derive sourceAddress from a verified ingress adapter, never arbitrary forwarding headers. */
+export function signPublicAdmissionAssertion(binding, attribution, keys, now) {
+    const address = attribution.sourceAddress.includes(',')
+        ? undefined
+        : clientAddressBucket(attribution.sourceAddress);
+    const visitor = visitorBucket(attribution.visitorHint);
+    if (!address || keys.pseudonymKey.length < 32 || !validBinding(binding))
+        throw new Error('verified public admission attribution is unavailable');
+    const issuedAt = Math.floor(now.getTime() / 1000);
+    const epoch = dayKey(now);
+    const pseudonym = (kind, value) => createHmac('sha256', keys.pseudonymKey)
+        .update(JSON.stringify([binding.installationId, binding.surfaceId, epoch, kind, value]))
+        .digest('hex');
+    const assertion = {
+        ...binding,
+        version: 1,
+        keyVersion: keys.activeVersion,
+        issuer: 'noodle-portal',
+        audience: 'noodle-public-admission',
+        epoch,
+        issuedAt,
+        expiresAt: issuedAt + PUBLIC_ADMISSION_ASSERTION_TTL_SECONDS,
+        network: pseudonym('network', address),
+        ...(visitor ? { visitor: pseudonym('visitor', visitor) } : {}),
+    };
+    const encoded = Buffer.from(JSON.stringify(assertion)).toString('base64url');
+    return `${encoded}.${signature(encoded, signingKey(keys, keys.activeVersion)).toString('base64url')}`;
+}
+export function verifyPublicAdmissionAssertion(token, expected, keys, now) {
+    if (token.length > 4096 || !validBinding(expected))
+        return undefined;
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 2 || !parts.every((part) => /^[A-Za-z0-9_-]+$/.test(part)))
+            return undefined;
+        const encoded = parts[0] ?? '';
+        const assertion = JSON.parse(Buffer.from(encoded, 'base64url').toString('utf8'));
+        if (!isAssertion(assertion))
+            return undefined;
+        const supplied = Buffer.from(parts[1] ?? '', 'base64url');
+        const correct = signature(encoded, signingKey(keys, assertion.keyVersion));
+        if (supplied.length !== correct.length || !timingSafeEqual(supplied, correct))
+            return undefined;
+        const seconds = Math.floor(now.getTime() / 1000);
+        if (assertion.epoch !== dayKey(now) ||
+            assertion.epoch !== dayKey(new Date(assertion.issuedAt * 1000)) ||
+            assertion.issuedAt > seconds + CLOCK_SKEW_SECONDS ||
+            assertion.expiresAt < seconds - CLOCK_SKEW_SECONDS ||
+            assertion.expiresAt <= assertion.issuedAt ||
+            assertion.expiresAt - assertion.issuedAt > PUBLIC_ADMISSION_ASSERTION_TTL_SECONDS)
+            return undefined;
+        if (Object.entries(expected).some(([key, value]) => assertion[key] !== value))
+            return undefined;
+        return {
+            network: assertion.network,
+            ...(assertion.visitor ? { visitor: assertion.visitor } : {}),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function signingKey(keys, version) {
+    const key = Object.hasOwn(keys.keys, version) ? keys.keys[version] : undefined;
+    if (!key || key.length < 32 || !/^[A-Za-z0-9_-]{1,32}$/.test(version))
+        throw new Error('public admission signing key unavailable');
+    return key;
+}
+function signature(encoded, key) {
+    return createHmac('sha256', key).update(encoded).digest();
+}
+function validBinding(value) {
+    return ([value.surfaceId, value.installationId, value.idempotencyKey].every((item) => typeof item === 'string' && item.length > 0 && item.length <= 128) &&
+        value.method === 'POST' &&
+        typeof value.route === 'string' &&
+        value.route.startsWith('/') &&
+        value.route.length <= 512 &&
+        digestPattern.test(value.requestDigest));
+}
+function isAssertion(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const a = value;
+    return (validBinding(a) &&
+        a.version === 1 &&
+        a.issuer === 'noodle-portal' &&
+        a.audience === 'noodle-public-admission' &&
+        typeof a.keyVersion === 'string' &&
+        typeof a.epoch === 'string' &&
+        Number.isSafeInteger(a.issuedAt) &&
+        Number.isSafeInteger(a.expiresAt) &&
+        typeof a.network === 'string' &&
+        digestPattern.test(a.network) &&
+        (a.visitor === undefined || digestPattern.test(a.visitor)) &&
+        Object.keys(a).every((key) => [
+            'surfaceId',
+            'installationId',
+            'route',
+            'method',
+            'idempotencyKey',
+            'requestDigest',
+            'version',
+            'keyVersion',
+            'issuer',
+            'audience',
+            'epoch',
+            'issuedAt',
+            'expiresAt',
+            'network',
+            'visitor',
+        ].includes(key)));
+}
+//# sourceMappingURL=public-admission-assertion.js.map

package/node_modules/@noodle-borg/admission-limits/dist/public-record-admission.d.ts

@@ -0,0 +1,54 @@
+import type { CounterRequest, DailyCounterStore } from './counter-store.js';
+export declare const PUBLIC_RECORD_ADMISSION_DEFAULTS: Readonly<{
+    visitorPerMinute: 300;
+    visitorPerHour: 3000;
+    networkPerMinute: 600;
+    networkPerHour: 6000;
+    installationPerDay: 10000;
+}>;
+export type PublicRecordAdmissionLimits = {
+    readonly [Key in keyof typeof PUBLIC_RECORD_ADMISSION_DEFAULTS]: number;
+};
+export type PublicRecordLimitCategory = 'visitor' | 'network' | 'installation';
+export type PublicRecordAdmissionResult = {
+    readonly allowed: true;
+} | {
+    readonly allowed: false;
+    readonly reason: 'admission_unavailable';
+} | {
+    readonly allowed: false;
+    readonly reason: 'idempotency_conflict';
+} | {
+    readonly allowed: false;
+    readonly reason: 'quota_exceeded';
+    readonly resetAt: Date;
+    readonly limits: readonly {
+        readonly category: PublicRecordLimitCategory;
+        readonly limit: number;
+        readonly resetAt: Date;
+    }[];
+};
+/** Channel-independent admission of one validated logical native create, after completed receipt replay. */
+export declare function admitPublicRecord(input: {
+    readonly counters: DailyCounterStore;
+    readonly surfaceId: string;
+    readonly attempt: {
+        readonly key: string;
+        readonly fingerprint: string;
+    };
+    readonly buckets: {
+        readonly visitor?: string;
+        readonly network?: string;
+    };
+    readonly now: Date;
+    readonly limits?: Partial<PublicRecordAdmissionLimits>;
+}): Promise<PublicRecordAdmissionResult>;
+/** Deployment-owned lower limits retain the same counter identities and accumulated usage. */
+export declare function publicRecordAdmissionLimits(configured?: Partial<PublicRecordAdmissionLimits>): PublicRecordAdmissionLimits;
+export declare function publicRecordCounterRequests(surfaceId: string, buckets: {
+    readonly visitor?: string;
+    readonly network?: string;
+}, limits?: PublicRecordAdmissionLimits): readonly (CounterRequest & {
+    readonly category: PublicRecordLimitCategory;
+})[];
+//# sourceMappingURL=public-record-admission.d.ts.map

package/node_modules/@noodle-borg/admission-limits/dist/public-record-admission.js

@@ -0,0 +1,74 @@
+export const PUBLIC_RECORD_ADMISSION_DEFAULTS = Object.freeze({
+    visitorPerMinute: 300,
+    visitorPerHour: 3_000,
+    networkPerMinute: 600,
+    networkPerHour: 6_000,
+    installationPerDay: 10_000,
+});
+/** Channel-independent admission of one validated logical native create, after completed receipt replay. */
+export async function admitPublicRecord(input) {
+    if (!input.buckets.network)
+        return { allowed: false, reason: 'admission_unavailable' };
+    if (!('consumeAllOnce' in input.counters) || typeof input.counters.consumeAllOnce !== 'function')
+        return { allowed: false, reason: 'admission_unavailable' };
+    try {
+        const requests = publicRecordCounterRequests(input.surfaceId, input.buckets, publicRecordAdmissionLimits(input.limits));
+        const outcome = await input.counters.consumeAllOnce(requests, input.attempt, input.now);
+        if (outcome.kind === 'consumed' || outcome.kind === 'replayed')
+            return { allowed: true };
+        if (outcome.kind === 'conflict')
+            return { allowed: false, reason: 'idempotency_conflict' };
+        if (outcome.kind !== 'refused' || outcome.exhausted.length === 0)
+            throw new Error('invalid atomic admission result');
+        const limits = outcome.exhausted.map((counter) => ({
+            category: requests.find((request) => request.key === counter.key)?.category ?? 'installation',
+            limit: counter.limit,
+            resetAt: counter.resetAt,
+        }));
+        return {
+            allowed: false,
+            reason: 'quota_exceeded',
+            limits,
+            resetAt: new Date(Math.max(...limits.map((counter) => counter.resetAt.getTime()))),
+        };
+    }
+    catch {
+        return { allowed: false, reason: 'admission_unavailable' };
+    }
+}
+/** Deployment-owned lower limits retain the same counter identities and accumulated usage. */
+export function publicRecordAdmissionLimits(configured = {}) {
+    return Object.fromEntries(Object.entries(PUBLIC_RECORD_ADMISSION_DEFAULTS).map(([name, maximum]) => {
+        const value = configured[name] ?? maximum;
+        if (!Number.isSafeInteger(value) || value < 0 || value > maximum)
+            throw new Error('public record admission limits must be non-negative integers within the deployment ceiling');
+        return [name, value];
+    }));
+}
+export function publicRecordCounterRequests(surfaceId, buckets, limits = PUBLIC_RECORD_ADMISSION_DEFAULTS) {
+    const requests = [];
+    for (const category of ['visitor', 'network']) {
+        const bucket = buckets[category];
+        if (bucket === undefined)
+            continue;
+        requests.push({
+            key: `solution-intake:${category}:minute:${surfaceId}:${bucket}`,
+            category,
+            limit: limits[`${category}PerMinute`],
+            window: 'minute',
+        }, {
+            key: `solution-intake:${category}:hour:${surfaceId}:${bucket}`,
+            category,
+            limit: limits[`${category}PerHour`],
+            window: 'hour',
+        });
+    }
+    requests.push({
+        key: `solution-intake:surface:${surfaceId}`,
+        category: 'installation',
+        limit: limits.installationPerDay,
+        window: 'day',
+    });
+    return requests;
+}
+//# sourceMappingURL=public-record-admission.js.map

package/node_modules/@noodle-borg/admission-limits/dist/request-attribution.d.ts

@@ -0,0 +1,11 @@
+/** Private in-process attribution from an authenticated adapter, never a serialized assertion. */
+export declare function trustedPublicAdmission(input: {
+    readonly scope: string | undefined;
+    readonly sourceAddress: string | undefined;
+    readonly subject?: string;
+    readonly now?: Date;
+}): {
+    readonly network: string;
+    readonly visitor?: string;
+} | undefined;
+//# sourceMappingURL=request-attribution.d.ts.map

package/node_modules/@noodle-borg/admission-limits/dist/request-attribution.js

@@ -0,0 +1,19 @@
+import { createHash } from 'node:crypto';
+import { clientAddressBucket } from './client-address.js';
+/** Private in-process attribution from an authenticated adapter, never a serialized assertion. */
+export function trustedPublicAdmission(input) {
+    if (!input.scope || !input.sourceAddress || input.sourceAddress.includes(','))
+        return undefined;
+    const address = clientAddressBucket(input.sourceAddress);
+    if (address === undefined)
+        return undefined;
+    const epoch = (input.now ?? new Date()).toISOString().slice(0, 10);
+    const digest = (kind, value) => createHash('sha256')
+        .update(JSON.stringify([input.scope, epoch, kind, value]))
+        .digest('hex');
+    return {
+        network: digest('network', address),
+        ...(input.subject ? { visitor: digest('visitor', input.subject) } : {}),
+    };
+}
+//# sourceMappingURL=request-attribution.js.map

package/node_modules/@noodle-borg/agent-kit/dist/curated/error-fixes.js

@@ -52,6 +52,8 @@ export const ERROR_FIXES = {
     invalid_knowledge: 'Fix the `knowledge()` declaration: documents must be existing UTF-8 `.md`/`.txt` files inside the project root (no symlinks), within the 100-file / 1 MiB / 25 MiB bounds, and sites need an exact HTTPS origin plus at least one include glob.',
     knowledge_unhashed: 'Compile from the project root (`noodle validate`/`noodle dev`) so declared knowledge documents can be read and hashed.',
     invalid_managed_collection: 'Fix the `managedCollection()` declaration: use a bounded, closed Zod object without credential, payment-card, government-identity, health, or biometric field names.',
+    invalid_variable_declaration: 'Fix the typed `variable()` declaration: use a bounded closed schema, a matching JSON default, plain Portal metadata, existing requiredFor tool names, and one consistent definition per key.',
+    invalid_managed_collection_source: 'Bind the declared source connector and select read-only scan operations whose closed normalized envelopes use the collection record schema exactly.',
     unknown_connector_alias: 'The tool calls a connector alias not declared in `use`/`provides`; add it or fix the alias (see `suggestions`).',
     connector_not_in_catalog: 'The referenced connector is not in the resolved catalog; add it to the project connectors or correct the reference.',
     unknown_operation: 'The connector has no such operation; use an operation declared on that connector (see `didYouMean`/`suggestions`).',