@noodleseed/one 0.154.0 → 0.156.0

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.33.0",
+    "@noodleseed/assistant": "1.34.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;
@@ -255,6 +290,12 @@ export interface AssistantSurfaceConfig {
     readonly webmcp?: {
         readonly enabled?: boolean;
     };
+    /**
+     * Present only on a public or mixed surface; an authenticated one never carries it.
+     *
+     * @see PublicWebsiteInput.continuity
+     */
+    readonly continuity?: AssistantContinuityDeclaration;
 }
 export interface EmbeddedAssistantConfig extends AssistantUiOptions {
     readonly model: AssistantModel;

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/authoring/dist/recording.d.ts

@@ -2,7 +2,7 @@ import type { ConnectorRef } from './connectors.js';
 import type { AmbientContextOptions } from './context.js';
 import type { ResourceContext, ToolOptions } from './server.js';
 export type SymbolicScope = Ref & Record<string, Ref>;
-export type ConnectorClient = Record<string, (args?: Readonly<Record<string, unknown>>) => Ref>;
+export type ConnectorClient = Record<string, (args?: Readonly<Record<string, unknown>>) => SymbolicScope>;
 type RecordedStep = {
     readonly id: string;
     readonly use: string;

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

@@ -383,15 +383,15 @@ export const ASSISTANT_COMMAND = {
         subcommand({
             ...SUBCOMMAND_FIELDS,
             name: 'embed',
-            summary: 'Scaffold the embedding web app: session route, client-only mount, env example, and coding-agent instructions.',
+            summary: 'Install the selected website integration with explicit application-owned seams and verification guidance.',
             flags: [
                 flag({
                     ...FLAG_FIELDS,
                     name: 'framework',
                     type: 'string',
                     value: '<framework>',
-                    summary: 'Embedding scaffold framework.',
-                    constraints: { choices: ['nextjs'], default: 'nextjs' },
+                    summary: 'Embedding profile: nextjs or authenticated django-vue.',
+                    constraints: { choices: ['nextjs', 'django-vue'], default: 'nextjs' },
                 }),
                 flag({
                     ...FLAG_FIELDS,
@@ -407,6 +407,12 @@ export const ASSISTANT_COMMAND = {
                     type: 'boolean',
                     summary: 'Overwrite user-modified scaffold files.',
                 }),
+                flag({
+                    ...FLAG_FIELDS,
+                    name: 'dry-run',
+                    type: 'boolean',
+                    summary: 'Preview generated files, hashes, conflicts, and next steps without writing files.',
+                }),
                 flag({
                     ...FLAG_FIELDS,
                     name: 'no-agents',
@@ -432,7 +438,7 @@ export const ASSISTANT_COMMAND = {
                     name: 'surface',
                     type: 'string',
                     value: '<mode>',
-                    summary: 'Surface mode this host serves; public drops backend credentials and public/mixed also check script-src.',
+                    summary: 'Surface to install or check; public omits backend exchange, mixed adds the existing-login handoff.',
                     constraints: { choices: ['authenticated', 'public', 'mixed'], default: 'authenticated' },
                 }),
                 flag({

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

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

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import type { PackagedAssetReference } from '../assets.js';
 type ToolAuthorizationManifest = {
     readonly requiredScopes?: readonly string[] | undefined;
     readonly allowedRoles?: readonly string[] | undefined;
@@ -381,6 +380,11 @@ export declare const manifestV1Schema: z.ZodObject<{
                 webmcp: z.ZodOptional<z.ZodObject<{
                     enabled: z.ZodOptional<z.ZodBoolean>;
                 }, z.core.$strict>>;
+                continuity: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodOptional<z.ZodBoolean>;
+                    windowSeconds: z.ZodOptional<z.ZodNumber>;
+                    maxRestores: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
             }, z.core.$strict>>>;
             sessionClaims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                 exposeToModel: z.ZodOptional<z.ZodBoolean>;
@@ -395,18 +399,18 @@ export declare const manifestV1Schema: z.ZodObject<{
             surface: z.ZodOptional<z.ZodString>;
             surfaceDark: z.ZodOptional<z.ZodString>;
             logo: z.ZodOptional<z.ZodObject<{
-                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>;
-                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>>;
+                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>;
+                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>>;
                 alt: z.ZodString;
             }, z.core.$strict>>;
             mark: z.ZodOptional<z.ZodObject<{
-                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>;
-                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>>;
+                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>;
+                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>>;
                 alt: z.ZodString;
             }, z.core.$strict>>;
             avatar: z.ZodOptional<z.ZodObject<{
-                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>;
-                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>>;
+                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>;
+                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>>;
                 alt: z.ZodString;
             }, z.core.$strict>>;
             theme: z.ZodOptional<z.ZodObject<{
@@ -864,6 +868,11 @@ export declare const manifestV2Schema: z.ZodObject<{
                 webmcp: z.ZodOptional<z.ZodObject<{
                     enabled: z.ZodOptional<z.ZodBoolean>;
                 }, z.core.$strict>>;
+                continuity: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodOptional<z.ZodBoolean>;
+                    windowSeconds: z.ZodOptional<z.ZodNumber>;
+                    maxRestores: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
             }, z.core.$strict>>>;
             sessionClaims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                 exposeToModel: z.ZodOptional<z.ZodBoolean>;
@@ -878,18 +887,18 @@ export declare const manifestV2Schema: z.ZodObject<{
             surface: z.ZodOptional<z.ZodString>;
             surfaceDark: z.ZodOptional<z.ZodString>;
             logo: z.ZodOptional<z.ZodObject<{
-                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>;
-                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>>;
+                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>;
+                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>>;
                 alt: z.ZodString;
             }, z.core.$strict>>;
             mark: z.ZodOptional<z.ZodObject<{
-                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>;
-                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>>;
+                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>;
+                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>>;
                 alt: z.ZodString;
             }, z.core.$strict>>;
             avatar: z.ZodOptional<z.ZodObject<{
-                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>;
-                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>>;
+                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>;
+                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>>;
                 alt: z.ZodString;
             }, z.core.$strict>>;
             theme: z.ZodOptional<z.ZodObject<{
@@ -1557,6 +1566,11 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 webmcp: z.ZodOptional<z.ZodObject<{
                     enabled: z.ZodOptional<z.ZodBoolean>;
                 }, z.core.$strict>>;
+                continuity: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodOptional<z.ZodBoolean>;
+                    windowSeconds: z.ZodOptional<z.ZodNumber>;
+                    maxRestores: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
             }, z.core.$strict>>>;
             sessionClaims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                 exposeToModel: z.ZodOptional<z.ZodBoolean>;
@@ -1571,18 +1585,18 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             surface: z.ZodOptional<z.ZodString>;
             surfaceDark: z.ZodOptional<z.ZodString>;
             logo: z.ZodOptional<z.ZodObject<{
-                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>;
-                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>>;
+                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>;
+                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>>;
                 alt: z.ZodString;
             }, z.core.$strict>>;
             mark: z.ZodOptional<z.ZodObject<{
-                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>;
-                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>>;
+                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>;
+                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>>;
                 alt: z.ZodString;
             }, z.core.$strict>>;
             avatar: z.ZodOptional<z.ZodObject<{
-                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>;
-                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>>;
+                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>;
+                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>>;
                 alt: z.ZodString;
             }, z.core.$strict>>;
             theme: z.ZodOptional<z.ZodObject<{
@@ -2039,6 +2053,11 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 webmcp: z.ZodOptional<z.ZodObject<{
                     enabled: z.ZodOptional<z.ZodBoolean>;
                 }, z.core.$strict>>;
+                continuity: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodOptional<z.ZodBoolean>;
+                    windowSeconds: z.ZodOptional<z.ZodNumber>;
+                    maxRestores: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
             }, z.core.$strict>>>;
             sessionClaims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                 exposeToModel: z.ZodOptional<z.ZodBoolean>;
@@ -2053,18 +2072,18 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             surface: z.ZodOptional<z.ZodString>;
             surfaceDark: z.ZodOptional<z.ZodString>;
             logo: z.ZodOptional<z.ZodObject<{
-                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>;
-                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>>;
+                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>;
+                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>>;
                 alt: z.ZodString;
             }, z.core.$strict>>;
             mark: z.ZodOptional<z.ZodObject<{
-                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>;
-                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>>;
+                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>;
+                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>>;
                 alt: z.ZodString;
             }, z.core.$strict>>;
             avatar: z.ZodOptional<z.ZodObject<{
-                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>;
-                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<PackagedAssetReference, unknown, z.core.$ZodTypeInternals<PackagedAssetReference, unknown>>]>>;
+                uri: z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>;
+                darkUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodType<import("../assets.js").PackagedAssetReference, unknown, z.core.$ZodTypeInternals<import("../assets.js").PackagedAssetReference, unknown>>]>>;
                 alt: z.ZodString;
             }, z.core.$strict>>;
             theme: z.ZodOptional<z.ZodObject<{