@noodleseed/one 0.139.4 → 0.141.0

package/node_modules/@noodle-borg/service/dist/routes/assistant-session-target.js

@@ -1,23 +1,49 @@
-import { projectArtifactForSurface, publicSurfaceOf, } from '@noodle-borg/assistant-gateway/portable';
+import { authenticatedSurfaceOf, projectArtifactForSurface, publicSurfaceOf, surfaceBindingForOrigin, } from '@noodle-borg/assistant-gateway/portable';
 export async function sessionScopedTarget(registry, session) {
     const target = await registry.get(session.deploymentId);
     if (!target)
         return undefined;
-    // Keyed on the embed id, not `identityKind`: after elevation a signed-in visitor on a mixed surface
-    // keeps the surface that admitted them, and should keep its projection with it.
-    if (session.publicEmbedId === undefined)
+    const assistant = target.served.artifact.server.assistant;
+    const bound = session.boundSurface ?? deriveLegacyBinding(assistant, session);
+    if (bound === 'pre-surfaces')
         return target;
-    const surface = publicSurfaceOf(target.served.artifact.server.assistant);
-    // Fail closed. A rollback to an artifact with no public surface must end the session's reach, never
-    // hand it the unprojected server.
+    // Fail closed: an origin no surface owns must never widen to the whole server.
+    if (bound === 'unowned')
+        return undefined;
+    // Fail closed on a vanished surface. A rollback to an artifact without the bound surface must end the
+    // session's reach, never hand it the unprojected server.
+    if (bound === 'authenticated') {
+        const surface = authenticatedSurfaceOf(assistant);
+        if (surface === undefined)
+            return undefined;
+        // An omitted allowlist on an authenticated surface is the authored whole-server intent, so the
+        // exact binding still holds (instructions, budgets, attribution) without narrowing capabilities.
+        if (surface.capabilities === undefined)
+            return target;
+        return projected(target, surface.capabilities);
+    }
+    const surface = publicSurfaceOf(assistant);
     if (surface === undefined)
         return undefined;
+    return projected(target, surface.capabilities);
+}
+function projected(target, capabilities) {
     return {
         ...target,
         served: {
             ...target.served,
-            artifact: projectArtifactForSurface(target.served.artifact, surface.capabilities),
+            artifact: projectArtifactForSurface(target.served.artifact, capabilities),
         },
     };
 }
+/**
+ * A record minted before `boundSurface` existed: the embed id marks the public surface; otherwise the
+ * session's origin selects the owning surface on the pinned deployment. `pre-surfaces` means the whole
+ * server on that released artifact shape; `unowned` fails closed above.
+ */
+function deriveLegacyBinding(assistant, session) {
+    if (session.publicEmbedId !== undefined)
+        return 'public';
+    return surfaceBindingForOrigin(assistant, session.origin).kind;
+}
 //# sourceMappingURL=assistant-session-target.js.map

package/node_modules/@noodle-borg/service/dist/routes/assistant-transcript.js

@@ -0,0 +1,27 @@
+import { visibleTranscript } from '@noodle-borg/assistant-gateway/portable';
+import { assistantTranscriptResponseSchema } from '@noodle-borg/wire-contracts';
+import { sendJson } from '../http-util.js';
+import { applyBrowserCors, authenticateSession } from './assistant-route-http.js';
+/**
+ * The bounded visible-transcript read (ADR 0141/0201 amendments 2026-08-26), in its own module for
+ * the same reason `assistant-elevation.ts` is: `assistant.ts` is at its size limit, and this is a
+ * different responsibility from running a turn.
+ *
+ * POST, deliberately: every other session route is a POST, so the existing preflight's
+ * `POST, OPTIONS` shape covers it without widening allow-methods. Auth is exactly the shared
+ * session gate — current token, pinned origin — so a stale pre-elevation token cannot read, by
+ * construction. A read spends no turn budget: admission binds metered work (ADR 0201 decision 8),
+ * and this is a projection over state that already exists and already expires with the session.
+ */
+export async function handleAssistantTranscript(req, res, deps) {
+    const session = await authenticateSession(req, res, deps);
+    if (!session)
+        return;
+    applyBrowserCors(req, res, session.origin);
+    const body = { entries: visibleTranscript(session.history) };
+    // Parse before sending, like the session exchange: a contract break fails loudly here rather than
+    // stranding deployed widgets (ADR 0151).
+    assistantTranscriptResponseSchema.parse(body);
+    return sendJson(res, 200, body);
+}
+//# sourceMappingURL=assistant-transcript.js.map

package/node_modules/@noodle-borg/service/dist/routes/assistant.js

@@ -1,5 +1,5 @@
 import { clientAddressBucket, } from '@noodle-borg/admission-limits/portable';
-import { ASSISTANT_SESSION_IDLE_MS, dispatchAssistantTool, parseAssistantContextPreferences, parseAssistantCustomerRouting, resumeTurnMessage, shouldAutoResume, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
+import { ASSISTANT_SESSION_IDLE_MS, dispatchAssistantTool, parseAssistantContextPreferences, parseAssistantCustomerRouting, resumeTurnMessage, resumeUnavailableMessage, shouldAutoResume, surfaceBindingForOrigin, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
 import { canonicalizeAuthorizationClaimValues } from '@noodle-borg/auth';
 import { validateJsonSchemaWithDefaults } from '@noodle-borg/compiler';
 import { tenantMcpUrl } from '@noodle-borg/module';
@@ -14,7 +14,7 @@ import { assistantBrowserConfiguration } from './assistant-configuration.js';
 import { elevateAssistantSession } from './assistant-elevation.js';
 import { executeAssistantKnowledgeSearch, findAssistantKnowledgeComponent, resolveAssistantKnowledge, } from './assistant-knowledge.js';
 import { refusePublicTurn } from './assistant-public-turn.js';
-import { applyBrowserCors, authenticateSession, handleAssistantPreflight, now, } from './assistant-route-http.js';
+import { applyBrowserCors, assistantSessionEndpoints, authenticateSession, handleAssistantPreflight, now, } from './assistant-route-http.js';
 import { sessionScopedTarget } from './assistant-session-target.js';
 import { authorizeControlPlane } from './control-plane.js';
 export { applyBrowserCors, authenticateSession, handleAssistantPreflight, now };
@@ -42,108 +42,6 @@ export async function handleConsoleApprovalNonce(req, res, deps) {
     const consumed = await deps.store.consumeConsoleApprovalNonce(nonce, identity.subject, expiry, current);
     return sendJson(res, consumed ? 201 : 409, consumed ? { ok: true } : { ok: false, error: 'already_used_or_expired' });
 }
-export async function handleAssistantClients(req, res, tenant, id, action, deps) {
-    const identity = await authorizeControlPlane(req, res, deps.gate, { requireIdentity: false });
-    if (identity === false)
-        return;
-    if (identity && !identity.superAdmin) {
-        const member = await deps.controlPlane.isOrgMember({
-            org: tenant.org,
-            subject: identity.subject,
-        });
-        if (!member)
-            return sendForbidden(res, 'forbidden');
-    }
-    if (action === 'collection' && req.method === 'GET') {
-        const clients = await deps.store.listClients(tenant);
-        return sendJson(res, 200, {
-            ok: true,
-            clients: clients.map(publicClient),
-        });
-    }
-    if (action === 'collection' && req.method === 'POST') {
-        const body = await readJsonBody(req, deps.maxBody);
-        if (!body.ok)
-            return sendJson(res, body.status, { error: body.error });
-        const name = body.value.name;
-        if (typeof name !== 'string' || name.trim().length < 1 || name.length > 80) {
-            return sendJson(res, 400, { error: '"name" must be a non-empty string' });
-        }
-        const target = await deps.registry.getActiveByTenant(tenant);
-        const assistant = target?.served.artifact.server.assistant;
-        if (!target?.deploymentId || !assistant)
-            return sendJson(res, 409, { error: 'deployment has no embedded assistant' });
-        const created = await deps.store.createClient({
-            name: name.trim(),
-            tenant,
-            deploymentId: target.deploymentId,
-            allowedOrigins: assistant.allowedOrigins,
-            now: now(deps),
-        });
-        await deps.audit.emit({
-            eventType: 'assistant.client.created',
-            org: tenant.org,
-            app: tenant.app,
-            env: tenant.env,
-            deploymentId: target.deploymentId,
-            decision: 'allow',
-            status: 201,
-            ...(identity ? { actorSubject: identity.subject } : {}),
-            ...(identity?.email ? { actorEmail: identity.email } : {}),
-            details: { clientId: created.client.id, name: created.client.name },
-        });
-        return sendJson(res, 201, {
-            ok: true,
-            ...publicClient(created.client),
-            clientSecret: created.secret,
-        });
-    }
-    if (!id)
-        return sendJson(res, 404, { error: 'not found' });
-    const owned = (await deps.store.listClients(tenant)).some((client) => client.id === id);
-    if (!owned)
-        return sendJson(res, 404, { error: 'not found' });
-    if (action === 'rotate' && req.method === 'POST') {
-        const rotated = await deps.store.rotateClient(id, now(deps));
-        if (!rotated)
-            return sendJson(res, 404, { error: 'not found' });
-        await deps.audit.emit({
-            eventType: 'assistant.client.rotated',
-            org: tenant.org,
-            app: tenant.app,
-            env: tenant.env,
-            deploymentId: rotated.client.deploymentId,
-            decision: 'allow',
-            status: 200,
-            ...(identity ? { actorSubject: identity.subject } : {}),
-            ...(identity?.email ? { actorEmail: identity.email } : {}),
-            details: { clientId: rotated.client.id },
-        });
-        return sendJson(res, 200, {
-            ok: true,
-            ...publicClient(rotated.client),
-            clientSecret: rotated.secret,
-        });
-    }
-    if (action === 'item' && req.method === 'DELETE') {
-        await deps.store.revokeClient(id, now(deps));
-        await deps.audit.emit({
-            eventType: 'assistant.client.revoked',
-            org: tenant.org,
-            app: tenant.app,
-            env: tenant.env,
-            decision: 'allow',
-            status: 204,
-            ...(identity ? { actorSubject: identity.subject } : {}),
-            ...(identity?.email ? { actorEmail: identity.email } : {}),
-            details: { clientId: id },
-        });
-        res.statusCode = 204;
-        res.end();
-        return;
-    }
-    sendJson(res, 405, { error: 'method not allowed' });
-}
 export async function handleAssistantSession(req, res, deps) {
     const usageStartedAt = performance.now();
     const credentials = basicCredentials(req);
@@ -173,6 +71,13 @@ export async function handleAssistantSession(req, res, deps) {
     if (!assistant.allowedOrigins.includes(parsed.origin)) {
         return sendForbidden(res, 'origin is not allowed');
     }
+    // Every session binds one exact authored surface (ADR 0201): the origin selects it, and an origin no
+    // surface owns is refused rather than admitted against the deployment-wide union. A pre-surfaces
+    // artifact has no surfaces to select from; its union remains its whole released contract.
+    const surfaceBinding = surfaceBindingForOrigin(assistant, parsed.origin);
+    if (surfaceBinding.kind === 'unowned') {
+        return sendForbidden(res, 'origin is not allowed');
+    }
     const customerRouting = parseAssistantCustomerRouting(target.served.artifact.customerEndpoints, parsed.routing);
     if (!customerRouting.ok) {
         return sendJson(res, 400, {
@@ -229,18 +134,15 @@ export async function handleAssistantSession(req, res, deps) {
             client,
             resume: shouldAutoResume(parsed.resume),
             origin: parsed.origin,
+            // The conversation lands on the surface owning the (validated) landing origin: signing in on
+            // the app surface continues under its projection (ADR 0201 amendment 2026-08-26).
+            ...(surfaceBinding.kind === 'pre-surfaces' ? {} : { boundSurface: surfaceBinding.kind }),
             ...(customerRouting.customerRouting
                 ? { customerRouting: customerRouting.customerRouting }
                 : {}),
             caller,
             configuration,
-            endpoints: {
-                turns: `${deps.serviceBase(req)}/v1/assistant/turns`,
-                toolConfirmations: `${deps.serviceBase(req)}/v1/assistant/tool-confirmations`,
-                interactions: `${deps.serviceBase(req)}/v1/assistant/interactions`,
-                apps: `${deps.serviceBase(req)}/v1/assistant/apps`,
-                sandbox: `${deps.serviceBase(req)}/v1/assistant/sandbox`,
-            },
+            endpoints: assistantSessionEndpoints(deps.serviceBase(req), deps.sandboxBase?.(req)),
         });
     }
     const session = await deps.store.createSession({
@@ -249,6 +151,7 @@ export async function handleAssistantSession(req, res, deps) {
         deploymentId: target.deploymentId,
         modelSource: assistant.model.kind === 'noodle-managed' ? 'noodle-managed' : 'operator',
         origin: parsed.origin,
+        ...(surfaceBinding.kind === 'pre-surfaces' ? {} : { boundSurface: surfaceBinding.kind }),
         ...(customerRouting.customerRouting
             ? { customerRouting: customerRouting.customerRouting }
             : {}),
@@ -263,13 +166,7 @@ export async function handleAssistantSession(req, res, deps) {
     const sessionBody = {
         token: session.token,
         expiresAt: session.session.expiresAt,
-        endpoints: {
-            turns: `${deps.serviceBase(req)}/v1/assistant/turns`,
-            toolConfirmations: `${deps.serviceBase(req)}/v1/assistant/tool-confirmations`,
-            interactions: `${deps.serviceBase(req)}/v1/assistant/interactions`,
-            apps: `${deps.serviceBase(req)}/v1/assistant/apps`,
-            sandbox: `${deps.serviceBase(req)}/v1/assistant/sandbox`,
-        },
+        endpoints: assistantSessionEndpoints(deps.serviceBase(req), deps.sandboxBase?.(req)),
         ...(configuration ? { configuration } : {}),
     };
     // Every published @noodleseed/assistant widget consumes this shape; parse (don't just test)
@@ -293,6 +190,7 @@ export async function handleAssistantTurn(req, res, deps) {
     const addressBucket = clientAddressBucket(typeof req.headers['x-forwarded-for'] === 'string' ? req.headers['x-forwarded-for'] : undefined);
     let turn;
     let message;
+    let resumedTool;
     if (isRecord(body.value) && 'resume' in body.value) {
         // The one-shot post-sign-in resume (issue #1177): no user text, the pending intent is server
         // state. Admission runs FIRST so a refused resume stays armed for a retry; the consume is a
@@ -313,6 +211,7 @@ export async function handleAssistantTurn(req, res, deps) {
             });
         }
         message = resumeTurnMessage(pending.tool);
+        resumedTool = pending.tool;
         await deps.audit.emit({
             eventType: 'assistant.session.resumed',
             org: session.tenant.org,
@@ -361,6 +260,12 @@ export async function handleAssistantTurn(req, res, deps) {
     const target = await sessionScopedTarget(deps.registry, session);
     if (!target)
         return sendJson(res, 409, { error: 'assistant deployment is unavailable' });
+    if (resumedTool !== undefined &&
+        !target.served.artifact.tools.some((tool) => tool.name === resumedTool)) {
+        // The elevation landed on a surface whose projection does not offer the intercepted tool: fail
+        // closed to an honest explanation instead of asking the model to call a tool it cannot see.
+        message = resumeUnavailableMessage(resumedTool);
+    }
     const clientContext = turn?.clientContext === undefined
         ? undefined
         : parseAssistantContextPreferences(turn.clientContext);
@@ -396,8 +301,11 @@ export async function handleAssistantTurn(req, res, deps) {
             .map((event) => String(event.data.delta ?? ''))
             .join('');
         await deps.store.appendHistory(session.id, [
-            { role: 'user', content: message.trim() },
-            ...(assistantContent ? [{ role: 'assistant', content: assistantContent }] : []),
+            // A resume turn's user row is the [platform] prompt the visitor never typed or saw.
+            { role: 'user', content: message.trim(), kind: turn ? 'visible' : 'narration' },
+            ...(assistantContent
+                ? [{ role: 'assistant', content: assistantContent, kind: 'visible' }]
+                : []),
         ]);
     }
     catch {
@@ -559,14 +467,4 @@ function isContext(value) {
                 typeof item === 'boolean' ||
                 (typeof item === 'string' && item.length <= 2_000))));
 }
-function publicClient(client) {
-    return {
-        id: client.id,
-        name: client.name,
-        createdAt: client.createdAt,
-        // Audit data only: sessions follow the tenant's active deployment, not this snapshot.
-        createdAgainstDeploymentId: client.deploymentId,
-        ...(client.revokedAt ? { revokedAt: client.revokedAt } : {}),
-    };
-}
 //# sourceMappingURL=assistant.js.map

package/node_modules/@noodle-borg/service/dist/routes/config-values.js

@@ -94,7 +94,7 @@ function developerConfigAccess(grants, controlPlane, ref, method) {
             controlPlane,
             org: ref.scope.org,
             capability: method === 'GET' ? 'cloud:read' : 'config:write',
-            resourcePath: DEVELOPER_CLI_PATH,
+            resourcePaths: new Set([DEVELOPER_CLI_PATH]),
         },
     };
 }

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

@@ -1,6 +1,6 @@
 import { cspFaultsInManifest } from '@noodle-borg/compiler';
 import { ensurePersonalWorkspace } from '@noodle-borg/control-plane/portable';
-import { DEVELOPER_CLI_PATH } from '@noodle-borg/developer-mcp';
+import { DEVELOPER_ASSISTANT_PATH, DEVELOPER_CLI_PATH, } from '@noodle-borg/developer-mcp';
 import { normalizeServerVersion } from '@noodle-borg/module';
 import { noopLogger } from '@noodle-borg/transport-http';
 import { deployRequestSchema, formatWireError, } from '@noodle-borg/wire-contracts';
@@ -504,9 +504,15 @@ export async function handleDeploymentStatus(req, res, registry, gate, controlPl
     }
 }
 export function developerGrantRouteAccess(grants, capability) {
+    // Control-plane routes serve the CLI resource and the assistant resource (ADR 0218); the grant's
+    // own capability ceiling — never this set — decides what each may actually do.
     return grants === undefined
         ? undefined
-        : { grants, capability, resourcePath: DEVELOPER_CLI_PATH };
+        : {
+            grants,
+            capability,
+            resourcePaths: new Set([DEVELOPER_CLI_PATH, DEVELOPER_ASSISTANT_PATH]),
+        };
 }
 async function authorizeHumanDeploy(req, res, options, gate, controlPlane, org) {
     const developerAccess = developerGrantAccess(options.developerGrantStore, controlPlane, org, 'deployments:write');

package/node_modules/@noodle-borg/service/dist/service-resource-cleanup.js

@@ -1,9 +1,5 @@
 /** Close every boot-owned resource, preserving all failures without skipping later cleanup. */
 export async function closeServiceResources(input) {
-    if (input.retentionTimer !== undefined)
-        clearInterval(input.retentionTimer);
-    if (input.intentRetentionTimer !== undefined)
-        clearInterval(input.intentRetentionTimer);
     if (input.welcomeEmailTimer !== undefined)
         clearInterval(input.welcomeEmailTimer);
     if (input.feedbackOperationsTimer !== undefined)
@@ -14,8 +10,7 @@ export async function closeServiceResources(input) {
     if (moduleHost !== undefined) {
         await captureCleanupError(errors, () => moduleHost.dispose());
     }
-    await captureCleanupError(errors, () => input.requestEventBuffer.close());
-    await captureCleanupError(errors, () => input.intentEventBuffer.close());
+    await captureCleanupError(errors, () => input.telemetry.dispose());
     const postgresPool = input.postgresPool;
     if (postgresPool !== undefined) {
         await captureCleanupError(errors, () => postgresPool.close());

package/node_modules/@noodle-borg/service/dist/service.js

@@ -1,4 +1,4 @@
-import { InMemoryAssistantStore } from '@noodle-borg/assistant-gateway/portable';
+import { InMemoryAssistantStore, isAssistantSandboxHost, validateAssistantSandboxBaseUrl, } from '@noodle-borg/assistant-gateway/portable';
 import { allowAllGate, InMemoryControlPlaneStore } from '@noodle-borg/control-plane/portable';
 import { dispatchKnowledgeRequest } from '@noodle-borg/knowledge-operations/portable';
 import { OPENAI_APPS_CHALLENGE_PATH } from '@noodle-borg/module';
@@ -50,6 +50,9 @@ const DEFAULT_MAX_BODY = 1 << 20;
 const DEFAULT_MAX_DEPLOY_BODY = 32 * 1024 * 1024;
 /** The combined service listener: tenant-scoped deploy management plus the multi-tenant MCP router. */
 export function createServiceHandler(registry, options = {}) {
+    const assistantSandboxBaseUrl = options.assistantSandboxBaseUrl === undefined
+        ? undefined
+        : validateAssistantSandboxBaseUrl(options.assistantSandboxBaseUrl, options.publicBaseUrl);
     const logger = options.logger ?? noopLogger;
     const tls = options.tls ?? {};
     const buildInfo = options.buildInfo ?? resolveBuildInfo();
@@ -155,6 +158,14 @@ export function createServiceHandler(registry, options = {}) {
     };
     return (req, res) => {
         const url = new URL(req.url ?? '/', 'http://localhost');
+        const onAssistantSandboxHost = isAssistantSandboxHost(req.headers.host, assistantSandboxBaseUrl);
+        if (onAssistantSandboxHost && url.pathname !== '/v1/assistant/sandbox') {
+            applySecurityHeaders(res, tls);
+            if (enforceHttps(req, res, tls))
+                return;
+            sendJson(res, 404, { error: 'not found' });
+            return;
+        }
         // Liveness/readiness probes: un-gated and **not** HTTPS-enforced — Cloud Run's internal probe is plain
         // HTTP, so enforcing HTTPS here would `426` the probe and the revision would never go healthy (ADR 0034).
         // `/healthz` is a pure liveness 200 (no store touch); `/readyz` reflects the injected readiness probe.
@@ -250,6 +261,9 @@ export function createServiceHandler(registry, options = {}) {
             audit: activeAudit,
             maxBody,
             serviceBase: (request) => options.publicBaseUrl ?? baseFromRequest(request, tls),
+            ...(assistantSandboxBaseUrl === undefined
+                ? {}
+                : { sandboxBase: () => assistantSandboxBaseUrl }),
             ...(options.assistantModelFetch !== undefined
                 ? { modelFetch: options.assistantModelFetch }
                 : {}),

package/node_modules/@noodle-borg/transport-http/dist/client-identity.js

@@ -0,0 +1,124 @@
+import { CLIENT_FAMILY_OTHER, CLIENT_FAMILY_UNKNOWN } from '@noodle-borg/module';
+/**
+ * Safe client attribution for request analytics (issue #1309): bounded projections of MCP
+ * `clientInfo` and of the transport user agent, plus the best-effort session→clientInfo memo that
+ * lets legacy-era requests after `initialize` keep their client identity. Nothing here ever retains
+ * a raw user-agent string, and every retained value is length-bounded and control-character free.
+ */
+const MAX_CLIENT_NAME = 128;
+const MAX_CLIENT_VERSION = 64;
+const MAX_FAMILY = 32;
+/**
+ * Known HTTP client user agents, matched case-insensitively against the user-agent prefix tokens.
+ * A closed table keeps the retained cardinality bounded: anything else becomes `other`, an absent
+ * user agent becomes `unknown`. Order matters — first match wins.
+ */
+const KNOWN_UA_FAMILIES = [
+    [/claude/i, 'claude'],
+    [/anthropic/i, 'anthropic-sdk'],
+    [/openai/i, 'openai'],
+    [/mcp-inspector|inspector/i, 'mcp-inspector'],
+    [/undici/i, 'undici'],
+    [/node-fetch/i, 'node-fetch'],
+    [/\bnode\b|nodejs/i, 'node'],
+    [/\bbun\b/i, 'bun'],
+    [/\bdeno\b/i, 'deno'],
+    [/python-httpx|\bhttpx\b/i, 'python-httpx'],
+    [/python-requests/i, 'python-requests'],
+    [/python-urllib|python/i, 'python'],
+    [/axios/i, 'axios'],
+    [/\bgot\b/i, 'got'],
+    [/curl/i, 'curl'],
+    [/wget/i, 'wget'],
+    [/postman/i, 'postman'],
+    [/insomnia/i, 'insomnia'],
+    [/go-http-client/i, 'go-http-client'],
+    [/okhttp/i, 'okhttp'],
+    [/java/i, 'java'],
+    [/mozilla|chrome|safari|firefox|edg/i, 'browser'],
+];
+/** Bound a wire-supplied client identity scalar: printable, trimmed, and length-capped. */
+export function boundedClientScalar(value, max) {
+    if (value === undefined)
+        return undefined;
+    let cleaned = '';
+    for (const char of value) {
+        const code = char.codePointAt(0) ?? 0;
+        if (code >= 0x20 && code !== 0x7f)
+            cleaned += char; // strip C0 controls and DEL
+    }
+    cleaned = cleaned.trim();
+    if (cleaned.length === 0)
+        return undefined;
+    return cleaned.length > max ? cleaned.slice(0, max) : cleaned;
+}
+export function boundedClientName(value) {
+    return boundedClientScalar(value, MAX_CLIENT_NAME);
+}
+export function boundedClientVersion(value) {
+    return boundedClientScalar(value, MAX_CLIENT_VERSION);
+}
+/**
+ * The bounded client family for one request. `clientInfo.name` wins (its sanitized token — the name
+ * itself is already retained, so the family adds no cardinality); otherwise the user agent maps
+ * through the closed table above; `other` for an unmatched agent, `unknown` for none at all.
+ */
+export function clientFamily(clientName, userAgent) {
+    if (clientName !== undefined) {
+        const token = clientName
+            .toLowerCase()
+            .replace(/[^a-z0-9._-]+/g, '-')
+            .replace(/^-+|-+$/g, '')
+            .slice(0, MAX_FAMILY);
+        if (token.length > 0)
+            return token;
+    }
+    if (userAgent === undefined || userAgent.trim().length === 0)
+        return CLIENT_FAMILY_UNKNOWN;
+    for (const [pattern, family] of KNOWN_UA_FAMILIES) {
+        if (pattern.test(userAgent))
+            return family;
+    }
+    return CLIENT_FAMILY_OTHER;
+}
+/**
+ * Bounded, best-effort LRU memo from an analytics session id to the `initialize` client identity,
+ * keyed per tenant so one tenant's session ids can never resolve another's client names. Purely an
+ * attribution aid: entries are non-authoritative, evicted oldest-first, and never required.
+ */
+export class SessionClientMemo {
+    #entries = new Map();
+    #cap;
+    constructor(cap = 2048) {
+        this.#cap = cap;
+    }
+    remember(key, identity) {
+        if (identity.clientName === undefined && identity.clientVersion === undefined)
+            return;
+        if (this.#entries.has(key))
+            this.#entries.delete(key);
+        this.#entries.set(key, identity);
+        if (this.#entries.size > this.#cap) {
+            const oldest = this.#entries.keys().next().value;
+            if (oldest !== undefined)
+                this.#entries.delete(oldest);
+        }
+    }
+    recall(key) {
+        const found = this.#entries.get(key);
+        if (found !== undefined) {
+            // Refresh recency so active sessions survive eviction pressure.
+            this.#entries.delete(key);
+            this.#entries.set(key, found);
+        }
+        return found;
+    }
+    get size() {
+        return this.#entries.size;
+    }
+}
+/** Tenant-scoped memo key; the org always participates so keys cannot collide across tenants. */
+export function sessionClientKey(org, app, env, sessionId) {
+    return `${org}/${app ?? ''}/${env ?? ''}#${sessionId}`;
+}
+//# sourceMappingURL=client-identity.js.map

package/node_modules/@noodle-borg/transport-http/dist/identity-authorization.js

@@ -11,12 +11,12 @@ export async function authorizeIdentityMode(req, res, auth) {
     const token = bearerToken(req);
     if (token === null || auth.verifyOwnerToken === undefined) {
         sendUnauthorized(res, challenge);
-        return { allow: false };
+        return { allow: false, reason: token === null ? 'missing_token' : 'verifier_unavailable' };
     }
     const verification = await auth.verifyOwnerToken(token, canonicalResourceUrl(req, auth));
     if (verification === null) {
         sendUnauthorized(res, challenge);
-        return { allow: false };
+        return { allow: false, reason: 'token_rejected' };
     }
     const { caller: identity } = verification;
     if (identity.identityKind === 'service') {
@@ -36,18 +36,18 @@ export async function authorizeIdentityMode(req, res, auth) {
     if (auth.accessMode === 'customers') {
         if (identity.identityKind !== 'customer') {
             sendUnauthorized(res, challenge);
-            return { allow: false };
+            return { allow: false, reason: 'identity_not_customer' };
         }
         return { allow: true, caller: identity, ...privateCustomerContext };
     }
     if (auth.accessMode === 'owner-only') {
         if (auth.ownerSubject === undefined) {
             sendUnauthorized(res, challenge);
-            return { allow: false };
+            return { allow: false, reason: 'owner_unconfigured' };
         }
         if (identity.subject !== auth.ownerSubject) {
             sendForbidden(res);
-            return { allow: false };
+            return { allow: false, reason: 'owner_mismatch' };
         }
         return { allow: true, caller: identity, ...privateCustomerContext };
     }
@@ -65,7 +65,7 @@ export async function authorizeIdentityMode(req, res, auth) {
             });
         if (membership?.allowed !== true) {
             sendForbidden(res);
-            return { allow: false };
+            return { allow: false, reason: 'org_membership_denied' };
         }
     }
     return { allow: true, caller: identity, ...privateCustomerContext };
@@ -90,12 +90,12 @@ export async function authorizeMixedMode(req, res, auth) {
     const challenge = protectedResourceMetadataUrl(req, auth);
     if (auth.verifyOwnerToken === undefined) {
         sendUnauthorized(res, challenge);
-        return { allow: false };
+        return { allow: false, reason: 'verifier_unavailable' };
     }
     const verification = await auth.verifyOwnerToken(token, canonicalResourceUrl(req, auth));
     if (verification === null) {
         sendUnauthorized(res, challenge);
-        return { allow: false };
+        return { allow: false, reason: 'token_rejected' };
     }
     return {
         allow: true,