@noodleseed/one 0.154.0 → 0.156.0

package/node_modules/@noodle-borg/compiler/dist/manifest/schema.js

@@ -3,6 +3,7 @@ import { z } from 'zod';
 import { MAX_COMPILED_WIDGET_HTML_BYTES, MAX_RAW_WIDGET_HTML_BYTES } from '../widget-limits.js';
 import { agentGuideSchema } from './agent-guide-schema.js';
 import { serverAuthSchema, serverAuthV2Schema } from './auth-schema.js';
+import { assistantOriginOrVariableSchema, httpsUrlSchema, managedVariableExpressionSchema, serverBrandingSchema, } from './branding-schema.js';
 import { NAME_PATTERN } from './naming.js';
 /**
  * Zod schema for Core v1 and v2 manifests (ADRs 0150 and 0157). V1 remains accepted unchanged;
@@ -133,82 +134,6 @@ const promptSchema = z.object({
     arguments: z.array(promptArgumentSchema).optional(),
     fulfilment: fulfilmentSchema,
 });
-const hexColorSchema = z.string().regex(/^#[0-9A-Fa-f]{6}$/, 'must be a 6-digit hex color');
-const httpsUrlSchema = z.url().regex(/^https:\/\//, 'must use https');
-const managedVariableExpressionPattern = /^\$\{env\.[A-Za-z0-9_]+\}$/;
-const managedVariableExpressionSchema = z
-    .string()
-    .regex(managedVariableExpressionPattern, 'must be an exact managed variable expression');
-// HTTP is allowed only for loopback development origins (mirrors the host-pattern loopback
-// exception used for connector/CSP origins); production embedding origins stay https-only.
-const assistantOriginOrVariablePattern = /^(?:\$\{env\.[A-Za-z0-9_]+\}|https:\/\/[^/?#@\\]+|http:\/\/(?:localhost|127\.0\.0\.1|\[::1\])(?::\d+)?)$/;
-function isCanonicalAssistantOrigin(value) {
-    try {
-        return new URL(value).origin === value;
-    }
-    catch {
-        return false;
-    }
-}
-const assistantOriginOrVariableSchema = z
-    .string()
-    .regex(assistantOriginOrVariablePattern, 'must be a canonical bare origin using https (http is allowed only for localhost/127.0.0.1/[::1] loopback development origins)')
-    .refine((value) => managedVariableExpressionPattern.test(value) || isCanonicalAssistantOrigin(value), 'must be a canonical bare origin');
-const packagedAssetSchema = z
-    .object({
-    kind: z.literal('asset'),
-    sourcePath: z.string().min(1),
-    logicalId: z.string().min(1),
-})
-    .strict();
-const brandAssetSchema = z
-    .object({
-    uri: z.union([httpsUrlSchema, packagedAssetSchema]),
-    darkUri: z.union([httpsUrlSchema, packagedAssetSchema]).optional(),
-    alt: z.string().trim().min(1),
-})
-    .strict();
-const brandThemeTokensSchema = z
-    .object({
-    surface: hexColorSchema.optional(),
-    surfaceRaised: hexColorSchema.optional(),
-    surfaceMuted: hexColorSchema.optional(),
-    text: hexColorSchema.optional(),
-    textMuted: hexColorSchema.optional(),
-    accent: hexColorSchema.optional(),
-    accentText: hexColorSchema.optional(),
-    link: hexColorSchema.optional(),
-    border: hexColorSchema.optional(),
-    borderStrong: hexColorSchema.optional(),
-    focus: hexColorSchema.optional(),
-    success: hexColorSchema.optional(),
-    warning: hexColorSchema.optional(),
-    danger: hexColorSchema.optional(),
-    code: hexColorSchema.optional(),
-})
-    .strict();
-const serverBrandingSchema = z
-    .object({
-    name: z.string().trim().min(1).optional(),
-    accent: hexColorSchema.optional(),
-    surface: hexColorSchema.optional(),
-    surfaceDark: hexColorSchema.optional(),
-    logo: brandAssetSchema.optional(),
-    mark: brandAssetSchema.optional(),
-    avatar: brandAssetSchema.optional(),
-    theme: z
-        .object({
-        light: brandThemeTokensSchema.optional(),
-        dark: brandThemeTokensSchema.optional(),
-    })
-        .strict()
-        .optional(),
-    radius: z.enum(['none', 'sm', 'md', 'lg']).optional(),
-    density: z.enum(['compact', 'comfortable']).optional(),
-    typography: z.enum(['system', 'serif', 'mono']).optional(),
-    colorScheme: z.enum(['auto', 'light', 'dark']).optional(),
-})
-    .strict();
 const assistantPresentationToneSchema = z.enum(['neutral', 'success', 'warning', 'danger']);
 const optionalStrictObject = (shape) => z.object(shape).strict().optional();
 const assistantPresentationSchema = z
@@ -357,6 +282,18 @@ const embeddedAssistantSchema = z
         // `assistantUiSchema.shape` — this is not renderer presentation, and a surface that
         // acquired it by a spread would be an accident rather than a decision.
         webmcp: optionalStrictObject({ enabled: z.boolean().optional() }),
+        // Anonymous cross-page display continuity (ADR 0223, clauses 11-16), declared per public
+        // or mixed surface. These bounds mirror the structural ceilings the gateway clamps to at
+        // runtime; the ADR is the single source, and this package cannot import the gateway
+        // because the dependency runs the other way. Refusing rather than clamping is deliberate:
+        // the gateway narrows an operator's value silently by design, but a developer who asks
+        // for more than the ceiling has made a mistake, and silence would hide it until someone
+        // measured the live behaviour.
+        continuity: optionalStrictObject({
+            enabled: z.boolean().optional(),
+            windowSeconds: z.number().int().min(0).max(600).optional(),
+            maxRestores: z.number().int().min(0).max(10).optional(),
+        }),
     })
         .strict())
         .min(1)
@@ -374,6 +311,17 @@ const embeddedAssistantSchema = z
     .strict()
     .superRefine((assistant, ctx) => {
     assistant.surfaces?.forEach((surface, index) => {
+        // The authenticated direction already reattaches through ADR 0223 clause 7, authorized by a
+        // backend-verified subject rather than by possession of a handle. A `continuity` block here
+        // would be a developer believing they configured something nothing reads, so refuse it rather
+        // than drop it silently.
+        if (surface.mode === 'authenticated' && surface.continuity !== undefined) {
+            ctx.addIssue({
+                code: 'custom',
+                path: ['surfaces', index, 'continuity'],
+                message: 'continuity belongs on a public or mixed website surface',
+            });
+        }
         if (surface.mode === 'authenticated')
             return;
         // A public surface fails closed: an omitted allowlist would otherwise read as "expose

package/node_modules/@noodle-borg/compiler/package.json

@@ -28,7 +28,6 @@
     "@noodle-borg/uri-template": "0.0.0",
     "@noodle-borg/knowledge": "0.0.0",
     "@noodle-borg/capabilities": "0.0.0",
-    "tailwindcss": "^4.3.1",
     "tldts": "^7.4.9",
     "yaml": "^2.9.0",
     "zod": "^4.4.3"

package/node_modules/@noodle-borg/deploy-client/dist/deploy-payload-size.js

@@ -9,8 +9,12 @@ function largestWidgetContributors(manifest) {
     try {
         const parsed = JSON.parse(manifest);
         const contributors = (parsed.widgets ?? [])
-            .filter((widget) => typeof widget.name === 'string' && typeof widget.html === 'string')
-            .map((widget) => ({ name: widget.name, bytes: Buffer.byteLength(widget.html) }))
+            .flatMap((widget) => {
+            const html = widget.html ?? widget.view?.compiledHtml;
+            return typeof widget.name === 'string' && typeof html === 'string'
+                ? [{ name: widget.name, bytes: Buffer.byteLength(html) }]
+                : [];
+        })
             .sort((left, right) => right.bytes - left.bytes)
             .slice(0, 3);
         return contributors.length === 0

package/node_modules/@noodle-borg/service/dist/registry-helpers.d.ts

@@ -15,7 +15,7 @@ export type ActiveDeployProvenance = {
     readonly ownerSubject: string | undefined;
 } | undefined;
 /** Resolve the durable owner binding while keeping legacy creator-only records readable. */
-export declare function deploymentOwnerSubject(record: DeployRecord): string | undefined;
+export declare function deploymentOwnerSubject(record: Pick<DeployRecord, 'ownerSubject' | 'createdBySubject'>): string | undefined;
 export declare function missingCapabilityErrors(required: readonly CapabilityName[], available: readonly CapabilityName[]): readonly DeployError[];
 export declare function missingSecretErrors(bindings: readonly SecretBinding[], secrets: Readonly<Record<string, string>>): DeployError[];
 export declare function missingVariableErrors(bindings: readonly string[], variables: Readonly<Record<string, string>>): DeployError[];

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

@@ -1,14 +1,24 @@
+import { randomUUID } from 'node:crypto';
 import { cspFaultsInManifest } from '@noodle-borg/compiler';
 import { readDeployBody, sendJson } from '@noodle-borg/transport-http';
-import { deployPreflightRequestSchema, formatWireError } from '@noodle-borg/wire-contracts';
+import { DEPLOY_PREFLIGHT_CHECK_TIMEOUT_MS, deployPreflightRequestSchema, formatWireError, } from '@noodle-borg/wire-contracts';
 import { manifestUsesUserRoot } from '../registry-access.js';
 import { isIdentityAccessMode } from './access-mode.js';
 import { authorizeDeploymentOwnerSelection, authorizeTenantControl, developerGrantRouteAccess, } from './control-plane.js';
+// Per-process resource admission, not a tenant quota or distributed state authority.
+const activePreflights = new WeakSet();
 /**
  * Read-only first-deploy readiness. It intentionally does not verify uploaded asset bytes:
  * the CLI calls this before it requests upload targets or sends any bytes.
  */
 export async function handleDeployPreflight(req, res, registry, options, maxBody, tenant, gate, controlPlane, audit) {
+    const startedAt = Date.now();
+    const suppliedId = req.headers['x-request-id'];
+    const requestId = typeof suppliedId === 'string' &&
+        /^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i.test(suppliedId)
+        ? suppliedId
+        : randomUUID();
+    res.setHeader('x-request-id', requestId);
     const identity = await authorizeTenantControl(req, res, gate, controlPlane, tenant.org, developerGrantRouteAccess(options.developerGrantStore, 'deployments:write'));
     if (identity === false)
         return;
@@ -25,111 +35,198 @@ export async function handleDeployPreflight(req, res, registry, options, maxBody
             error: 'app is archived; restore it before deploying',
         });
     }
-    const body = await readDeployBody(req, maxBody);
-    if (!body.ok)
-        return sendJson(res, body.status, { error: body.error });
-    let parsed;
-    try {
-        const raw = JSON.parse(body.text);
-        const result = deployPreflightRequestSchema.safeParse(raw);
-        if (!result.success)
-            throw new Error(formatWireError(result.error));
-        parsed = result.data;
-    }
-    catch (error) {
-        return sendJson(res, 400, {
-            code: 'invalid_deploy_request',
-            error: `invalid deploy preflight request: ${error.message}`,
+    if (activePreflights.has(registry)) {
+        await audit.emit({
+            eventType: 'deploy.preflight.rejected',
+            ...tenant,
+            actorSubject: identity.subject,
+            decision: 'deny',
+            status: 503,
+            reasonCode: 'deploy_preflight_busy',
+            details: { requestId, phase: 'admission', elapsedMs: Date.now() - startedAt },
         });
-    }
-    const accessMode = parsed.accessMode ?? 'owner-only';
-    if (isIdentityAccessMode(accessMode) && identity === undefined) {
-        return sendJson(res, 401, {
-            code: 'deployer_identity_required',
-            error: `${accessMode} deployments require an authenticated deployer`,
+        res.setHeader('retry-after', '5');
+        return sendJson(res, 503, {
+            code: 'deploy_preflight_busy',
+            phase: 'admission',
+            error: 'This instance is already checking a deployment. Retry once after the indicated delay.',
         });
     }
-    const ownerSelection = await authorizeDeploymentOwnerSelection(res, controlPlane, tenant.org, accessMode, identity, parsed.ownerSubject);
-    if (!ownerSelection.ok)
-        return;
-    if (accessMode === 'public' && manifestUsesUserRoot(parsed.manifest)) {
-        return sendJson(res, 400, {
-            code: 'public_user_context_conflict',
-            error: 'public access mode cannot reference ${user}; use mixed for optional identity',
+    activePreflights.add(registry);
+    let clientDisconnected = false;
+    let deadlineExceeded = false;
+    let phase = 'body';
+    let timer;
+    const onClose = () => {
+        if (!res.writableFinished)
+            clientDisconnected = true;
+    };
+    res.once('close', onClose);
+    try {
+        await audit.emit({
+            eventType: 'deploy.preflight.started',
+            ...tenant,
+            actorSubject: identity.subject,
+            decision: 'allow',
+            details: { requestId, phase, elapsedMs: Date.now() - startedAt },
         });
-    }
-    const [cspFault] = cspFaultsInManifest(parsed.manifest);
-    if (cspFault !== undefined) {
-        return sendJson(res, 400, {
-            code: 'invalid_widget_csp',
-            error: `widget "${cspFault.widget}" CSP ${cspFault.list} origin "${cspFault.value}" is not an ` +
-                `absolute https:// origin and would be dropped by the host renderer` +
-                (cspFault.suggestion !== undefined ? `; use "${cspFault.suggestion}"` : ''),
+        const body = await readDeployBody(req, maxBody);
+        if (req.aborted || res.destroyed)
+            return;
+        if (!body.ok)
+            return sendJson(res, body.status, { error: body.error });
+        phase = 'validation';
+        let parsed;
+        try {
+            const raw = JSON.parse(body.text);
+            const result = deployPreflightRequestSchema.safeParse(raw);
+            if (!result.success)
+                throw new Error(formatWireError(result.error));
+            parsed = result.data;
+        }
+        catch (error) {
+            return sendJson(res, 400, {
+                code: 'invalid_deploy_request',
+                error: `invalid deploy preflight request: ${error.message}`,
+            });
+        }
+        const accessMode = parsed.accessMode ?? 'owner-only';
+        if (isIdentityAccessMode(accessMode) && identity === undefined) {
+            return sendJson(res, 401, {
+                code: 'deployer_identity_required',
+                error: `${accessMode} deployments require an authenticated deployer`,
+            });
+        }
+        const ownerSelection = await authorizeDeploymentOwnerSelection(res, controlPlane, tenant.org, accessMode, identity, parsed.ownerSubject);
+        if (!ownerSelection.ok)
+            return;
+        if (accessMode === 'public' && manifestUsesUserRoot(parsed.manifest)) {
+            return sendJson(res, 400, {
+                code: 'public_user_context_conflict',
+                error: 'public access mode cannot reference ${user}; use mixed for optional identity',
+            });
+        }
+        const [cspFault] = cspFaultsInManifest(parsed.manifest);
+        if (cspFault !== undefined) {
+            return sendJson(res, 400, {
+                code: 'invalid_widget_csp',
+                error: `widget "${cspFault.widget}" CSP ${cspFault.list} origin "${cspFault.value}" is not an ` +
+                    `absolute https:// origin and would be dropped by the host renderer` +
+                    (cspFault.suggestion !== undefined ? `; use "${cspFault.suggestion}"` : ''),
+            });
+        }
+        phase = 'checks';
+        timer = setTimeout(() => {
+            deadlineExceeded = true;
+            if (!res.headersSent && !res.destroyed)
+                sendJson(res, 504, {
+                    code: 'deploy_preflight_timeout',
+                    phase,
+                    error: `Preflight exceeded its ${DEPLOY_PREFLIGHT_CHECK_TIMEOUT_MS}ms checking budget. Publication did not start.`,
+                });
+        }, DEPLOY_PREFLIGHT_CHECK_TIMEOUT_MS);
+        const pending = [
+            registry.getApp(tenant.org, tenant.app),
+            registry.getEnvironment(tenant.org, tenant.app, tenant.env),
+            registry.preflightDeploy(tenant, parsed.manifest, {
+                ...(parsed.connectors !== undefined ? { connectors: parsed.connectors } : {}),
+                actor: identity,
+                accessMode,
+                ownerSubject: ownerSelection.ownerSubject,
+                ...(parsed.orgMembershipSources !== undefined
+                    ? { orgMembershipSources: parsed.orgMembershipSources }
+                    : {}),
+                ...(parsed.hostedAssets !== undefined ? { hostedAssets: parsed.hostedAssets } : {}),
+                ...(parsed.serverVersion !== undefined ? { serverVersion: parsed.serverVersion } : {}),
+                deploymentSource: parsed.deploymentSource ?? 'cli',
+            }),
+        ];
+        const checked = await Promise.all(pending)
+            .catch(async (error) => {
+            // Keep the resource slot until every already-started check settles, including after a timeout.
+            await Promise.allSettled(pending);
+            throw error;
+        })
+            .finally(() => clearTimeout(timer));
+        const [application, environment, preflight] = checked;
+        const errors = preflight.ok ? [] : preflight.errors;
+        const missingSecrets = configNames(errors, 'missing_secret', 'secrets.');
+        const missingVariables = configNames(errors, 'missing_variable', 'variables.');
+        const appState = application === undefined ? 'will-create' : 'existing';
+        const environmentState = environment === undefined ? 'will-create' : 'existing';
+        const ready = errors.length === 0;
+        const codes = [...new Set(errors.map((error) => error.code))].sort().join(',');
+        await audit.emit({
+            eventType: 'deploy.preflight.checked',
+            org: tenant.org,
+            app: tenant.app,
+            env: tenant.env,
+            decision: 'allow',
+            status: 200,
+            actorSubject: identity.subject,
+            ...(identity.email !== undefined ? { actorEmail: identity.email } : {}),
+            details: {
+                requestId,
+                phase,
+                elapsedMs: Date.now() - startedAt,
+                clientDisconnected,
+                deadlineExceeded,
+                ready,
+                appState,
+                environmentState,
+                ...(ownerSelection.ownerSubject !== undefined
+                    ? { ownerSubject: ownerSelection.ownerSubject }
+                    : {}),
+                errorCount: errors.length,
+                codes,
+                missingSecretCount: missingSecrets.length,
+                missingVariableCount: missingVariables.length,
+            },
         });
-    }
-    const [application, environment, preflight] = await Promise.all([
-        registry.getApp(tenant.org, tenant.app),
-        registry.getEnvironment(tenant.org, tenant.app, tenant.env),
-        registry.preflightDeploy(tenant, parsed.manifest, {
-            ...(parsed.connectors !== undefined ? { connectors: parsed.connectors } : {}),
-            actor: identity,
-            accessMode,
-            ownerSubject: ownerSelection.ownerSubject,
-            ...(parsed.orgMembershipSources !== undefined
-                ? { orgMembershipSources: parsed.orgMembershipSources }
-                : {}),
-            ...(parsed.hostedAssets !== undefined ? { hostedAssets: parsed.hostedAssets } : {}),
-            ...(parsed.serverVersion !== undefined ? { serverVersion: parsed.serverVersion } : {}),
-            deploymentSource: parsed.deploymentSource ?? 'cli',
-        }),
-    ]);
-    const errors = preflight.ok ? [] : preflight.errors;
-    const missingSecrets = configNames(errors, 'missing_secret', 'secrets.');
-    const missingVariables = configNames(errors, 'missing_variable', 'variables.');
-    const appState = application === undefined ? 'will-create' : 'existing';
-    const environmentState = environment === undefined ? 'will-create' : 'existing';
-    const ready = errors.length === 0;
-    const codes = [...new Set(errors.map((error) => error.code))].sort().join(',');
-    await audit.emit({
-        eventType: 'deploy.preflight.checked',
-        org: tenant.org,
-        app: tenant.app,
-        env: tenant.env,
-        decision: 'allow',
-        status: 200,
-        actorSubject: identity.subject,
-        ...(identity.email !== undefined ? { actorEmail: identity.email } : {}),
-        details: {
+        if (deadlineExceeded || clientDisconnected || res.destroyed)
+            return;
+        return sendJson(res, 200, {
+            ok: true,
             ready,
-            appState,
-            environmentState,
             ...(ownerSelection.ownerSubject !== undefined
                 ? { ownerSubject: ownerSelection.ownerSubject }
                 : {}),
-            errorCount: errors.length,
-            codes,
-            missingSecretCount: missingSecrets.length,
-            missingVariableCount: missingVariables.length,
-        },
-    });
-    return sendJson(res, 200, {
-        ok: true,
-        ready,
-        ...(ownerSelection.ownerSubject !== undefined
-            ? { ownerSubject: ownerSelection.ownerSubject }
-            : {}),
-        target: {
+            target: {
+                ...tenant,
+                appState,
+                environmentState,
+            },
+            config: {
+                ready: missingSecrets.length === 0 && missingVariables.length === 0,
+                missingSecrets,
+                missingVariables,
+            },
+            errors,
+        });
+    }
+    catch (error) {
+        await audit.emit({
+            eventType: 'deploy.preflight.failed',
             ...tenant,
-            appState,
-            environmentState,
-        },
-        config: {
-            ready: missingSecrets.length === 0 && missingVariables.length === 0,
-            missingSecrets,
-            missingVariables,
-        },
-        errors,
-    });
+            actorSubject: identity.subject,
+            decision: 'deny',
+            status: res.headersSent ? res.statusCode : 500,
+            reasonCode: 'preflight_failed',
+            details: {
+                requestId,
+                phase,
+                elapsedMs: Date.now() - startedAt,
+                clientDisconnected,
+                deadlineExceeded,
+            },
+        });
+        throw error;
+    }
+    finally {
+        clearTimeout(timer);
+        res.removeListener('close', onClose);
+        activePreflights.delete(registry);
+    }
 }
 function configNames(errors, code, prefix) {
     return [

package/node_modules/@noodle-borg/service/package.json

@@ -39,7 +39,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@noodle-borg/admission-limits": "0.0.0",
-    "@noodle-borg/agent-kit": "0.93.0",
+    "@noodle-borg/agent-kit": "0.94.0",
     "@noodle-borg/app-package": "0.0.0",
     "@noodle-borg/assistant-gateway": "0.0.0",
     "@noodle-borg/auth": "0.0.0",

package/node_modules/@noodle-borg/wire-contracts/dist/index.d.ts

@@ -137,6 +137,9 @@ export declare const deployErrorResponseSchema: z.ZodObject<{
     errors: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>;
 export type DeployErrorResponse = z.infer<typeof deployErrorResponseSchema>;
+/** Checking budget after upload/authorization; the client allows additional upload/response time. */
+export declare const DEPLOY_PREFLIGHT_CHECK_TIMEOUT_MS = 60000;
+export declare const DEPLOY_PREFLIGHT_CLIENT_TIMEOUT_MS = 75000;
 /**
  * `POST /v1/orgs/{org}/apps/{app}/envs/{env}/deploy/preflight` accepts the same
  * declarative input as deploy, but performs no deployment or asset upload.

package/node_modules/@noodle-borg/wire-contracts/dist/index.js

@@ -109,6 +109,9 @@ export const deployErrorResponseSchema = z.object({
     errors: z.unknown().optional(),
 });
 // ─── Deploy preflight ─────────────────────────────────────────────────────────────
+/** Checking budget after upload/authorization; the client allows additional upload/response time. */
+export const DEPLOY_PREFLIGHT_CHECK_TIMEOUT_MS = 60_000;
+export const DEPLOY_PREFLIGHT_CLIENT_TIMEOUT_MS = 75_000;
 /**
  * `POST /v1/orgs/{org}/apps/{app}/envs/{env}/deploy/preflight` accepts the same
  * declarative input as deploy, but performs no deployment or asset upload.

package/node_modules/@noodleseed/assistant/README.md

@@ -6,7 +6,8 @@ The package exports the canonical `<noodle-assistant>` managed Web Component, th
 `<noodle-app-view>` MCP App host from `@noodleseed/assistant/app-view`, a managed React wrapper and
 `NoodleAppView` adapter from `@noodleseed/assistant/react`, a renderer-free React hook from
 `@noodleseed/assistant/react/client`, a DOM-free client from `@noodleseed/assistant/client`, and the
-backend-only `createAssistantSession` helper from `@noodleseed/assistant/server`. The component inherits the
+backend-only `createAssistantSessionHandler` and lower-level `createAssistantSession` exchange from
+`@noodleseed/assistant/server`. The component inherits the
 deployed MCP server's brand kit while slots, methods, events, and semantic CSS variables let a SaaS developer
 integrate it without depending on internal DOM selectors. Light, dark, automatic host-page matching, and
 host-page inversion work without replacing conversation or App DOM.
@@ -193,32 +194,29 @@ noodle assistant clients create --name web --org acme --app support --env prod
 
 The command saves `{ clientId, clientSecret }` to a mode-`0600` file and prints its path, never the secret.
 Move those values to the customer backend's secret manager without printing or committing them. A framework
-route can exchange the current signed-in user like this:
+route can use the maintained same-origin handler. Generate the route, authentication adapter, mount and
+contract tests with `noodle assistant embed --framework nextjs --surface authenticated` in the existing
+application. Implement only `authenticateAssistantRequest` using its existing session and membership checks:
 
 ```ts
-import { createAssistantSession } from "@noodleseed/assistant/server";
-
-export async function POST(request: Request) {
-  const user = await requireCurrentUser(request);
-  const { context } = await request.json();
-  const session = await createAssistantSession({
-    serviceUrl: process.env.NOODLE_SERVICE_URL!,
-    clientId: process.env.NOODLE_ASSISTANT_CLIENT_ID!,
-    clientSecret: process.env.NOODLE_ASSISTANT_CLIENT_SECRET!,
-    origin: process.env.PUBLIC_APP_ORIGIN!,
-    user: {
-      id: user.id,
-      email: user.email,
-      roles: user.roles,
-      scopes: user.scopes,
-    },
-    context,
-    preferences: { locale: user.locale, timeZone: user.timeZone },
-  });
-  return Response.json(session);
-}
+import { createAssistantSessionHandler } from "@noodleseed/assistant/server";
+import { authenticateAssistantRequest } from "../../../../lib/noodle-assistant-auth";
+
+export const POST = createAssistantSessionHandler({
+  serviceUrl: process.env.NOODLE_SERVICE_URL,
+  clientId: process.env.NOODLE_ASSISTANT_CLIENT_ID,
+  clientSecret: process.env.NOODLE_ASSISTANT_CLIENT_SECRET,
+  origin: process.env.PUBLIC_APP_ORIGIN,
+  authenticate: authenticateAssistantRequest,
+});
 ```
 
+The handler owns exact-Origin and JSON checks, signed-out JSON 401, bounded context/body parsing, no-store
+responses, a 15-second deadline, and sanitized exchange failures without retries or redirects. Your adapter
+returns `AssistantSessionIdentity | null`; its `user`, claims, preferences and routing must be backend-verified.
+Keep stricter application CSRF middleware. Run the generated contract suite and your real identity/tenant
+acceptance tests; synthetic contract tests alone do not verify your login implementation.
+
 For a connector that uses `customerEndpoint("customer_api", ...)`, the authenticated backend may also pass
 `routing: { endpoints: { customer_api: account.clusterApiBaseUrl } }`. Resolve the URL from server-owned
 user/account membership after authentication; never accept it from the browser, page context, session

package/node_modules/@noodleseed/assistant/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noodleseed/assistant",
-  "version": "1.33.0",
+  "version": "1.34.0",
   "description": "Embed the Noodle Seed customer-branded assistant in your web app with managed or framework-owned UI, a framework-neutral MCP App host, a DOM-free client, and a backend session helper. Authoring and deploying the server is @noodleseed/one.",
   "license": "Apache-2.0",
   "repository": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noodleseed/one",
-  "version": "0.154.0",
+  "version": "0.156.0",
   "private": false,
   "description": "Noodle CLI by Noodle Seed — author, run, and deploy declarative MCP servers. Embedding the assistant in your own web app is @noodleseed/assistant.",
   "license": "Apache-2.0",
@@ -205,7 +205,6 @@
     "shebang-command",
     "shebang-regex",
     "statuses",
-    "tailwindcss",
     "tldts",
     "tldts-core",
     "toidentifier",
@@ -236,7 +235,7 @@
     "@modelcontextprotocol/client": "2.0.0",
     "@modelcontextprotocol/server": "2.0.0",
     "@noodle-borg/admission-limits": "0.0.0",
-    "@noodle-borg/agent-kit": "0.93.0",
+    "@noodle-borg/agent-kit": "0.94.0",
     "@noodle-borg/app-audit": "0.0.0",
     "@noodle-borg/app-package": "0.0.0",
     "@noodle-borg/assistant-gateway": "0.0.0",
@@ -285,7 +284,9 @@
     "zod-to-json-schema": "3.25.2"
   },
   "devDependencies": {
-    "@types/node": "24.13.1"
+    "@noodleseed/assistant": "@noodleseed/assistant@file:///home/runner/work/noodle-borg/noodle-borg/packages/assistant",
+    "@types/node": "24.13.1",
+    "next": "16.2.9"
   },
   "optionalDependencies": {}
 }

package/dist/saas-scaffold-template.d.ts

@@ -1,4 +0,0 @@
-import type { ProjectAgentTarget } from './project.js';
-/** Default SaaS starter: the portable Apps surface plus customer identity and verified context. */
-export declare function saasFiles(name: string, agentTargets: readonly ProjectAgentTarget[]): Record<string, string>;
-//# sourceMappingURL=saas-scaffold-template.d.ts.map

package/dist/saas-scaffold-template.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"saas-scaffold-template.d.ts","sourceRoot":"","sources":["../src/saas-scaffold-template.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAGvD,mGAAmG;AACnG,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,SAAS,kBAAkB,EAAE,GAC1C,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA6DxB"}