@noodleseed/one 0.153.0 → 0.155.0

package/node_modules/@noodle-borg/assistant-gateway/dist/in-memory-continuity-store.d.ts

@@ -0,0 +1,26 @@
+import { type AssistantContinuityClaim, type AssistantContinuityContext, type AssistantContinuityRecord, type AssistantContinuityStore } from './continuity-store.js';
+import type { TenantRef } from './tenant-ref.js';
+/** The in-memory half of the pair. Both run the shared parity suite; neither is the only proof. */
+export declare class InMemoryAssistantContinuityStore implements AssistantContinuityStore {
+    #private;
+    issue(input: {
+        readonly sessionId: string;
+        readonly tenant: TenantRef;
+        readonly context: AssistantContinuityContext;
+        readonly windowMs?: number;
+        readonly maxRestores?: number;
+        readonly now: Date;
+    }): Promise<{
+        readonly record: AssistantContinuityRecord;
+        readonly handle: string;
+    } | undefined>;
+    claim(input: {
+        readonly handle: string;
+        readonly context: AssistantContinuityContext;
+        readonly now: Date;
+    }): Promise<AssistantContinuityClaim>;
+    sweepExpired(input: {
+        readonly now: Date;
+    }): Promise<number>;
+}
+//# sourceMappingURL=in-memory-continuity-store.d.ts.map

package/node_modules/@noodle-borg/assistant-gateway/dist/in-memory-continuity-store.js

@@ -0,0 +1,80 @@
+import { randomUUID } from 'node:crypto';
+import { continuityDigest, continuityHandle, continuityHashesEqual, continuityMaxRestores, continuityWindowMs, sameContinuityContext, } from './continuity-store.js';
+/** The in-memory half of the pair. Both run the shared parity suite; neither is the only proof. */
+export class InMemoryAssistantContinuityStore {
+    #rows = new Map();
+    async issue(input) {
+        return this.#write({ ...input, restoreCount: 0 });
+    }
+    async claim(input) {
+        const hash = continuityDigest(input.handle);
+        const found = [...this.#rows.values()].find((row) => continuityHashesEqual(row.handleHash, hash));
+        if (!found || found.claimedAt !== undefined)
+            return { ok: false, reason: 'unknown' };
+        // Context before expiry: a handle replayed from somewhere it was never issued should read as the
+        // exfiltration signal it is, whether or not the value happened to be stale by then.
+        if (!sameContinuityContext(found.context, input.context)) {
+            return { ok: false, reason: 'context_mismatch' };
+        }
+        if (Date.parse(found.expiresAt) <= input.now.getTime())
+            return { ok: false, reason: 'expired' };
+        const restoreCount = found.restoreCount + 1;
+        const claimed = {
+            ...found,
+            restoreCount,
+            claimedAt: input.now.toISOString(),
+        };
+        this.#rows.set(found.id, claimed);
+        if (restoreCount >= found.maxRestores)
+            return { ok: true, record: claimed };
+        const rotated = this.#write({
+            sessionId: found.sessionId,
+            tenant: found.tenant,
+            context: found.context,
+            // Re-derive from the record so a rotation can never widen what the first issue clamped.
+            windowMs: Date.parse(found.expiresAt) - Date.parse(found.createdAt),
+            maxRestores: found.maxRestores,
+            restoreCount,
+            now: input.now,
+        });
+        return rotated === undefined
+            ? { ok: true, record: claimed }
+            : { ok: true, record: claimed, handle: rotated.handle };
+    }
+    async sweepExpired(input) {
+        let removed = 0;
+        for (const [id, row] of this.#rows) {
+            if (row.claimedAt !== undefined || Date.parse(row.expiresAt) <= input.now.getTime()) {
+                this.#rows.delete(id);
+                removed++;
+            }
+        }
+        return removed;
+    }
+    #write(input) {
+        const windowMs = continuityWindowMs(input.windowMs);
+        const maxRestores = continuityMaxRestores(input.maxRestores);
+        if (windowMs === 0 || maxRestores === 0)
+            return undefined;
+        // Supersede rather than accumulate: one live handle per session.
+        for (const [id, row] of this.#rows) {
+            if (row.sessionId === input.sessionId && row.claimedAt === undefined)
+                this.#rows.delete(id);
+        }
+        const handle = continuityHandle();
+        const record = {
+            id: `cont_${randomUUID().replaceAll('-', '')}`,
+            sessionId: input.sessionId,
+            tenant: input.tenant,
+            context: input.context,
+            handleHash: continuityDigest(handle),
+            restoreCount: input.restoreCount,
+            maxRestores,
+            createdAt: input.now.toISOString(),
+            expiresAt: new Date(input.now.getTime() + windowMs).toISOString(),
+        };
+        this.#rows.set(record.id, record);
+        return { record, handle };
+    }
+}
+//# sourceMappingURL=in-memory-continuity-store.js.map

package/node_modules/@noodle-borg/assistant-gateway/dist/model-request.d.ts

@@ -94,6 +94,7 @@ export declare function requestModelCompletion(input: {
     readonly messages: readonly AssistantModelMessage[];
     readonly tools: readonly AssistantModelTool[];
     readonly toolChoice?: 'auto' | 'none' | 'required';
+    readonly jsonOutput?: boolean;
     readonly fetcher: (url: string, init: RequestInit) => Promise<Response>;
     readonly onContent?: (delta: string) => void;
     readonly maxResponseBytes?: number;

package/node_modules/@noodle-borg/assistant-gateway/dist/model-request.js

@@ -17,6 +17,7 @@ export async function requestModelCompletion(input) {
             store: false,
             input: responsesInput(input.messages),
             tools: responsesTools(input.tools),
+            ...(input.jsonOutput ? { text: { format: { type: 'json_object' } } } : {}),
             ...(input.toolChoice === undefined ? {} : { tool_choice: input.toolChoice }),
             ...(completionLimit === undefined ? {} : { max_output_tokens: completionLimit }),
         }
@@ -26,6 +27,7 @@ export async function requestModelCompletion(input) {
             stream: true,
             messages: input.messages,
             tools: input.tools,
+            ...(input.jsonOutput ? { response_format: { type: 'json_object' } } : {}),
             ...(input.toolChoice === undefined ? {} : { tool_choice: input.toolChoice }),
             ...(completionLimit === undefined ? {} : { max_completion_tokens: completionLimit }),
         });

package/node_modules/@noodle-borg/assistant-gateway/dist/model-response-values.js

@@ -0,0 +1,11 @@
+export function nonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+export async function readBoundedText(response, maxBytes) {
+    const text = await response.text();
+    if (new TextEncoder().encode(text).byteLength > maxBytes) {
+        throw new Error('model response too large');
+    }
+    return text;
+}
+//# sourceMappingURL=model-response-values.js.map

package/node_modules/@noodle-borg/assistant-gateway/dist/model-responses.js

@@ -1,3 +1,4 @@
+import { nonNegativeInteger, readBoundedText } from './model-response-values.js';
 export function responsesInput(messages) {
     return messages.flatMap((message) => {
         if (message.role === 'tool') {
@@ -150,14 +151,4 @@ function parseRecord(value) {
     }
     return value;
 }
-function nonNegativeInteger(value) {
-    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
-}
-async function readBoundedText(response, maxBytes) {
-    const text = await response.text();
-    if (new TextEncoder().encode(text).byteLength > maxBytes) {
-        throw new Error('model response too large');
-    }
-    return text;
-}
 //# sourceMappingURL=model-responses.js.map

package/node_modules/@noodle-borg/assistant-gateway/dist/model-stream.js

@@ -1,3 +1,4 @@
+import { nonNegativeInteger, readBoundedText } from './model-response-values.js';
 export async function readModelCompletion(response, onContent, maxBytes = 1 << 20) {
     const contentType = response.headers.get('content-type') ?? '';
     if (!contentType.includes('text/event-stream')) {
@@ -111,14 +112,4 @@ function normalizeUsageValue(usage) {
         ...(reasoningTokens === undefined ? {} : { reasoningTokens }),
     };
 }
-function nonNegativeInteger(value) {
-    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
-}
-async function readBoundedText(response, maxBytes) {
-    const text = await response.text();
-    if (new TextEncoder().encode(text).byteLength > maxBytes) {
-        throw new Error('model response too large');
-    }
-    return text;
-}
 //# sourceMappingURL=model-stream.js.map

package/node_modules/@noodle-borg/assistant-gateway/dist/portable.d.ts

@@ -17,12 +17,15 @@ export * from './assistant-store.js';
 export * from './assistant-transcript.js';
 export * from './assistant-transcript-events.js';
 export * from './assistant-view-availability.js';
+export * from './continuity-bounds.js';
+export * from './continuity-store.js';
 export * from './elevation.js';
 export * from './elevation-store.js';
 export * from './embed-operator-view.js';
 export * from './embed-script.js';
 export * from './embed-store.js';
 export * from './in-memory-assistant-appearance-store.js';
+export * from './in-memory-continuity-store.js';
 export * from './in-memory-elevation-store.js';
 export * from './in-memory-embed-store.js';
 export * from './managed-spend.js';

package/node_modules/@noodle-borg/assistant-gateway/dist/portable.js

@@ -17,12 +17,15 @@ export * from './assistant-store.js';
 export * from './assistant-transcript.js';
 export * from './assistant-transcript-events.js';
 export * from './assistant-view-availability.js';
+export * from './continuity-bounds.js';
+export * from './continuity-store.js';
 export * from './elevation.js';
 export * from './elevation-store.js';
 export * from './embed-operator-view.js';
 export * from './embed-script.js';
 export * from './embed-store.js';
 export * from './in-memory-assistant-appearance-store.js';
+export * from './in-memory-continuity-store.js';
 export * from './in-memory-elevation-store.js';
 export * from './in-memory-embed-store.js';
 export * from './managed-spend.js';

package/node_modules/@noodle-borg/assistant-gateway/package.json

@@ -42,7 +42,7 @@
     "@noodle-borg/module-audit": "0.0.0",
     "@noodle-borg/protocol": "0.0.0",
     "@noodle-borg/runtime": "0.0.0",
-    "@noodleseed/assistant": "1.32.0",
+    "@noodleseed/assistant": "1.33.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {

package/node_modules/@noodle-borg/authoring/dist/assistant.d.ts

@@ -173,6 +173,31 @@ export interface AuthenticatedWebsiteAccess {
         readonly enabled?: boolean;
     };
 }
+/**
+ * Anonymous cross-page display continuity for one public surface (ADR 0223, clauses 11-16).
+ *
+ * Off unless asked for. Anonymous conversation text is your content on your page, so whether it
+ * survives a navigation is your call rather than a default the platform imposes.
+ *
+ * What a visitor gets is the text they have already read, re-rendered on the next page, on a fresh
+ * session. What it never grants is the old session itself: no tool authority, no share of a spent
+ * turn budget, and no pending confirmation carried across — a capability that survives a navigation
+ * is exactly what this design refuses to create.
+ */
+export interface AssistantContinuityDeclaration {
+    readonly enabled?: boolean;
+    /**
+     * How long a handle stays valid after the turn that issued it, measured from when the visitor last
+     * spoke. Defaults to 300; 600 is the structural ceiling, and 0 disables continuity outright. An
+     * operator may lower what you declare here and can never raise it.
+     */
+    readonly windowSeconds?: number;
+    /**
+     * How many times one conversation may be restored before continuity ends and the next page starts
+     * fresh. Defaults to 3, ceiling 10, and 0 disables continuity outright.
+     */
+    readonly maxRestores?: number;
+}
 export interface PublicWebsiteAccess {
     readonly mode: 'public' | 'mixed';
     readonly origins: readonly string[];
@@ -182,6 +207,8 @@ export interface PublicWebsiteAccess {
     readonly webmcp?: {
         readonly enabled?: boolean;
     };
+    /** @see PublicWebsiteInput.continuity */
+    readonly continuity?: AssistantContinuityDeclaration;
 }
 export type AssistantAccess = AuthenticatedWebsiteAccess | PublicWebsiteAccess;
 export interface AuthenticatedWebsiteInput {
@@ -226,6 +253,14 @@ export interface PublicWebsiteInput {
     readonly webmcp?: {
         readonly enabled?: boolean;
     };
+    /**
+     * Let an anonymous visitor keep the conversation they can see when they navigate to another page
+     * of this site. Omitted means off, and no existing embed changes behavior.
+     *
+     * Declared only here, never on an authenticated surface: that direction reattaches through a
+     * backend-verified sign-in instead, so a declaration there would configure nothing.
+     */
+    readonly continuity?: AssistantContinuityDeclaration;
 }
 export declare function authenticatedWebsite(input: AuthenticatedWebsiteInput): AuthenticatedWebsiteAccess;
 export declare function publicWebsite(input: PublicWebsiteInput): PublicWebsiteAccess;

package/node_modules/@noodle-borg/authoring/dist/assistant.js

@@ -16,6 +16,7 @@ export function publicWebsite(input) {
         capabilities: [...input.capabilities],
         ...(input.instructions === undefined ? {} : { instructions: input.instructions }),
         ...(input.webmcp === undefined ? {} : { webmcp: { ...input.webmcp } }),
+        ...(input.continuity === undefined ? {} : { continuity: { ...input.continuity } }),
     };
 }
 function serializeOrigins(origins, path) {
@@ -59,6 +60,9 @@ export function embeddedAssistant(input) {
                 ? { sessionClaims: structuredClone(surface.sessionClaims) }
                 : {}),
             ...(surface.webmcp === undefined ? {} : { webmcp: { ...surface.webmcp } }),
+            ...(surface.mode !== 'authenticated' && surface.continuity !== undefined
+                ? { continuity: { ...surface.continuity } }
+                : {}),
         })),
         allowedOrigins: surfaces.flatMap((surface) => [...surface.origins]),
         ...structuredClone(ui),

package/node_modules/@noodle-borg/cli-catalog/dist/catalog-data-account.js

@@ -26,6 +26,11 @@ const JSON_FLAG = {
     type: 'boolean',
     summary: 'Emit JSON output.',
 };
+const REQUIRED_STRING_FLAG = {
+    ...OPTIONAL_FLAG,
+    type: 'string',
+    required: true,
+};
 const CAPABILITY_NAMES = [
     'identity',
     'access',
@@ -190,6 +195,97 @@ export const CATALOG_ACCOUNT = [
                 ],
                 jsonOutput: { mode: 'single' },
             },
+            {
+                name: 'app-purge',
+                summary: 'Reconcile historical app anchors after an already-recorded retention purge.',
+                arguments: [],
+                flags: [],
+                subcommands: [
+                    {
+                        name: 'preview',
+                        summary: 'Write a bounded exact-set reconciliation preview artifact.',
+                        arguments: [],
+                        flags: [
+                            {
+                                ...REQUIRED_STRING_FLAG,
+                                name: 'output',
+                                value: '<absolute-path>',
+                                summary: 'New absolute path for the exclusive 0600 preview artifact.',
+                                sensitive: false,
+                            },
+                            SERVICE,
+                            AUTH_TOKEN,
+                            JSON_FLAG,
+                        ],
+                        jsonOutput: { mode: 'single' },
+                    },
+                    {
+                        name: 'apply',
+                        summary: 'Apply one approved exact preview with recovery and approval evidence.',
+                        arguments: [],
+                        flags: [
+                            {
+                                ...REQUIRED_STRING_FLAG,
+                                name: 'approved-preview',
+                                value: '<absolute-path>',
+                                summary: 'Absolute path to the approved exact 0600 preview artifact.',
+                                sensitive: true,
+                            },
+                            {
+                                ...REQUIRED_STRING_FLAG,
+                                name: 'release-sha',
+                                value: '<sha>',
+                                summary: 'Exact deployed System Release SHA.',
+                                sensitive: false,
+                                constraints: { minLength: 40, maxLength: 40 },
+                            },
+                            {
+                                ...REQUIRED_STRING_FLAG,
+                                name: 'approval-reference',
+                                value: '<reference>',
+                                summary: 'Restricted founder or product-owner approval reference.',
+                                sensitive: true,
+                                constraints: { minLength: 1, maxLength: 256 },
+                            },
+                            {
+                                ...REQUIRED_STRING_FLAG,
+                                name: 'recovery-checkpoint',
+                                value: '<reference>',
+                                summary: 'Verified backup or point-in-time recovery checkpoint reference.',
+                                sensitive: true,
+                                constraints: { minLength: 1, maxLength: 256 },
+                            },
+                            {
+                                ...REQUIRED_STRING_FLAG,
+                                name: 'reason',
+                                value: '<reason>',
+                                summary: 'Bounded reconciliation reason.',
+                                sensitive: true,
+                                constraints: { minLength: 1, maxLength: 500 },
+                            },
+                            {
+                                ...REQUIRED_STRING_FLAG,
+                                name: 'idempotency-key',
+                                value: '<key>',
+                                summary: 'Private key for exact replay.',
+                                sensitive: true,
+                                constraints: { minLength: 8, maxLength: 256 },
+                            },
+                            {
+                                ...OPTIONAL_FLAG,
+                                name: 'yes',
+                                type: 'boolean',
+                                summary: 'Confirm the approved destructive operation.',
+                                required: true,
+                            },
+                            SERVICE,
+                            AUTH_TOKEN,
+                            JSON_FLAG,
+                        ],
+                        jsonOutput: { mode: 'single' },
+                    },
+                ],
+            },
         ],
     },
     {

package/node_modules/@noodle-borg/cli-catalog/dist/catalog-data-billing.js

@@ -62,6 +62,75 @@ const IDEMPOTENCY_FLAG = flag({
     required: true,
     sensitive: true,
 });
+const TRANSFER_ACCOUNT_FLAG = flag({
+    ...FLAG_FIELDS,
+    name: 'account',
+    type: 'string',
+    value: '<destination-id>',
+    summary: 'Destination billing account identifier.',
+    required: true,
+});
+const TRANSFER_ORG_FLAG = flag({
+    ...FLAG_FIELDS,
+    name: 'org',
+    type: 'string',
+    value: '<org>',
+    summary: 'Organization slug to transfer.',
+    required: true,
+});
+const TRANSFER_QUERY_FLAG = flag({
+    ...FLAG_FIELDS,
+    name: 'query',
+    type: 'string',
+    value: '<text>',
+    summary: 'Filter owned organizations by name or slug.',
+    constraints: { minLength: 1, maxLength: 100 },
+});
+const TRANSFER_CURSOR_FLAG = flag({
+    ...FLAG_FIELDS,
+    name: 'cursor',
+    type: 'string',
+    value: '<cursor>',
+    summary: 'Opaque continuation cursor.',
+    constraints: { maxLength: 512 },
+});
+const TRANSFER_LIMIT_FLAG = flag({
+    ...FLAG_FIELDS,
+    name: 'limit',
+    type: 'integer',
+    value: '<n>',
+    summary: 'Maximum organization candidates returned.',
+    constraints: { default: 50, minimum: 1, maximum: 100 },
+});
+const TRANSFER_OUT_FLAG = flag({
+    ...FLAG_FIELDS,
+    name: 'out',
+    type: 'string',
+    value: '<reviewed-preview.json>',
+    summary: 'New private path for the reviewed preview artifact.',
+    required: true,
+    sensitive: true,
+});
+const TRANSFER_PREVIEW_FILE_FLAG = flag({
+    ...FLAG_FIELDS,
+    name: 'preview-file',
+    type: 'string',
+    value: '<reviewed-preview.json>',
+    summary: 'Private reviewed billing transfer preview artifact.',
+    required: true,
+    sensitive: true,
+});
+const TRANSFER_IDEMPOTENCY_FLAG = flag({
+    ...IDEMPOTENCY_FLAG,
+    constraints: { minLength: 8, maxLength: 256 },
+});
+const TRANSFER_YES_FLAG = flag({ ...YES_FLAG, required: true });
+const TRANSFER_ADMIN_REASON_FLAG = flag({
+    ...REASON_FLAG,
+    summary: 'Restricted administrative reason recorded with the transfer.',
+    sensitive: true,
+    constraints: { minLength: 1, maxLength: 256 },
+});
 function leaf(name, summary, options) {
     return subcommand({
         ...SUBCOMMAND_FIELDS,
@@ -281,6 +350,50 @@ const MIGRATION = branch('migration', 'Run the super-admin-only legacy shadow-mi
         ],
     }),
 ]);
+const CUSTOMER_TRANSFER = branch('transfer', 'Move an owned organization to an eligible billing account.', [
+    leaf('candidates', 'List owned organizations with billing transfer status and eligibility.', {
+        ...LEAF_FIELDS,
+        flags: [
+            TRANSFER_ACCOUNT_FLAG,
+            TRANSFER_QUERY_FLAG,
+            TRANSFER_CURSOR_FLAG,
+            TRANSFER_LIMIT_FLAG,
+        ],
+    }),
+    leaf('preview', 'Preview an exact customer billing transfer without changing state.', {
+        arguments: [
+            argument({
+                ...ARGUMENT_FIELDS,
+                name: 'org-slug',
+                type: 'string',
+                summary: 'Owned organization slug to transfer.',
+                required: true,
+            }),
+        ],
+        flags: [TRANSFER_ACCOUNT_FLAG, TRANSFER_OUT_FLAG],
+    }),
+    leaf('apply', 'Apply an exact reviewed customer billing transfer.', {
+        ...LEAF_FIELDS,
+        flags: [TRANSFER_PREVIEW_FILE_FLAG, TRANSFER_IDEMPOTENCY_FLAG, TRANSFER_YES_FLAG],
+    }),
+]);
+const ADMINISTRATION = branch('administration', 'Perform restricted super-admin billing operations on behalf of users.', [
+    branch('transfer', 'Move organization billing with explicit super-admin authority.', [
+        leaf('preview', 'Preview an exact administrative billing transfer.', {
+            ...LEAF_FIELDS,
+            flags: [
+                TRANSFER_ORG_FLAG,
+                TRANSFER_ACCOUNT_FLAG,
+                TRANSFER_ADMIN_REASON_FLAG,
+                TRANSFER_OUT_FLAG,
+            ],
+        }),
+        leaf('apply', 'Apply an exact reviewed administrative billing transfer.', {
+            ...LEAF_FIELDS,
+            flags: [TRANSFER_PREVIEW_FILE_FLAG, TRANSFER_IDEMPOTENCY_FLAG, TRANSFER_YES_FLAG],
+        }),
+    ]),
+]);
 export const BILLING_COMMAND = {
     name: 'billing',
     section: 'operate',
@@ -289,7 +402,7 @@ export const BILLING_COMMAND = {
     arguments: [],
     subcommands: [
         ACCOUNTS,
-        branch('org', 'Inspect an organization’s effective billing entitlements.', [
+        branch('org', 'Inspect or transfer an organization’s effective billing.', [
             leaf('inspect', 'Inspect effective billing entitlements for one organization.', {
                 ...LEAF_FIELDS,
                 arguments: [
@@ -302,7 +415,9 @@ export const BILLING_COMMAND = {
                     }),
                 ],
             }),
+            CUSTOMER_TRANSFER,
         ]),
+        ADMINISTRATION,
         ENFORCEMENT,
         METERING,
         MIGRATION,

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

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+/**
+ * Shared manifest primitives: colors, https URLs, managed variable expressions, assistant origins,
+ * packaged asset references, and the server brand kit.
+ *
+ * Extracted verbatim from `schema.ts` so that file stays inside its size budget as the assistant
+ * surface grows. These are leaf validators with no dependency on tools, prompts, widgets, or the
+ * assistant block, which is what makes the split one-directional and free of an import cycle.
+ */
+const hexColorSchema = z.string().regex(/^#[0-9A-Fa-f]{6}$/, 'must be a 6-digit hex color');
+export const httpsUrlSchema = z.url().regex(/^https:\/\//, 'must use https');
+const managedVariableExpressionPattern = /^\$\{env\.[A-Za-z0-9_]+\}$/;
+export 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;
+    }
+}
+export 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();
+export 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();
+//# sourceMappingURL=branding-schema.js.map