@widgetic/creator 0.3.49

package/dist/components/WidgetDetails.svelte.d.ts

@@ -0,0 +1,235 @@
+import { AgentApi } from '@widgetic/api-sdk';
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const WidgetDetails: $$__sveltets_2_IsomorphicComponent<{
+    userSession?: {
+        jwt?: string;
+        user?: {
+            id?: string;
+        };
+    } | null;
+    hasValidToken?: boolean;
+    selectedWidgetId?: string | null;
+    selectedWidget?: {
+        [extra: string]: unknown;
+        id?: string;
+        created_at?: string | Date;
+        createdAt?: string | Date;
+        updated_at?: string | Date;
+        updatedAt?: string | Date;
+        repositoryId?: string | null;
+        repository_id?: string | null;
+        repoId?: string | null;
+        name?: string;
+        lastCpgCommitSha?: string | null;
+    } | null;
+    isGeneratingCode?: boolean;
+    skipBasePreview?: boolean;
+    /** 'pending' = repo being created (show loader); 'failed' = show Create Repository; 'ready' = normal. */ repositorySetupStatus?: "pending" | "ready" | "failed";
+    generateCodeStatus?: string | null;
+    isCheckingActiveGeneration?: boolean;
+    lastCommitId?: string | null;
+    debugMode?: boolean;
+    forceMockReady?: boolean;
+    debugModeAvailable?: boolean;
+    lastGenerationFailed?: boolean;
+    lastGenerationError?: string | null;
+    saveStatus?: "idle" | "saving" | "saved" | "error";
+    hasChangesToSave?: boolean;
+    isSaveDisabled?: boolean;
+    isGenerateDisabled?: boolean;
+    isPublishDisabled?: boolean;
+    isPublishing?: boolean;
+    publishWidgetStatus?: string | null;
+    publishNeedsSaveFirst?: boolean;
+    lastPublishedVersion?: number | null;
+    widgetJsPath?: string | null;
+    isGeneratingInOtherTab?: boolean;
+    isPublishingInOtherTab?: boolean;
+    isSettingLiveVersion?: number | null;
+    isHistoryOpen?: boolean;
+    isLoadingHistory?: boolean;
+    publishHistory?: any[];
+    agentClient: AgentApi;
+    codeGenerationPrompt?: string;
+    promptImages?: string[];
+    imageInputRef?: HTMLInputElement | null;
+    isDraggingImage?: boolean;
+    MAX_PROMPT_IMAGES?: number;
+    selectedModel?: {
+        id: string;
+        name: string;
+        provider: string;
+        description: string;
+    } | null;
+    availableModels?: {
+        id: string;
+        name: string;
+        provider: string;
+        description: string;
+    }[];
+    userSelectedModelId?: string;
+    modelsLoading?: boolean;
+    /** Published widget URL for Embed step (may include compositionId). Set by parent. */ embedPreviewUrl?: string | null;
+    /** Published widget base URL for Edit step when live matches latest commit. Null → Worker preview. */ editPreviewUrl?: string | null;
+    /** True when generated code is ahead of the live published artifact. */ hasUnpublishedChanges?: boolean;
+    /** Host API root (embedded site passes PUBLIC_API_URL). Used for published artifact proxy URLs. */ apiUrl?: string | null;
+    /** Host Widget Builder origin (site PUBLIC_WIDGET_BUILDER_URL). */ widgetBuilderUrl?: string | null;
+    /**
+         * Viewport top inset for centering/clamping the floating panel (site header / creator top bar).
+         * Parent should pass the embedded-aware value; null keeps the legacy auth-panel estimate.
+         */ panelTopOffset?: number | null;
+    /** Viewport bottom inset when sizing the default panel height. */ panelBottomMargin?: number | null;
+    /**
+         * When true (site embed), open the panel nearly full-viewport so Create/Edit
+         * chat + preview have room — not a narrow floating card over the canvas.
+         */ fillViewport?: boolean;
+    /** Stacking order when multiple Widget Details panels are open. */ panelZIndex?: number;
+    /** Cascade offset index (0 = centered, 1+ = shifted down-right). */ panelCascadeIndex?: number;
+    /** False when another panel has keyboard/chat focus. */ isFocusedPanel?: boolean;
+    currentStep?: "create" | "edit" | "embed";
+    beginCompositionHydration?: () => void;
+    finishCompositionHydration?: () => void;
+    markCodegenPreviewFresh?: () => void;
+    hasLiveWorkerPreview?: () => boolean;
+    getLatestRuntimeLogs?: (maxLines?: number) => string[];
+    resumeDeferredPreviewLoad?: () => Promise<void>;
+    loadWidget?: (widgetId: string | null) => Promise<void>;
+    invalidatePublishedArtifactCache?: () => void;
+    refreshPreview?: (opts?: {
+        withRetry?: boolean;
+        skipIfAlreadyShowing?: boolean;
+    }) => Promise<void>;
+    triggerBuildFromRepo?: (options?: {
+        force?: boolean;
+    }) => Promise<void>;
+    enqueueAction?: (action: {
+        type: "generate";
+        prompt: string;
+    } | {
+        type: "save";
+    }) => void;
+    getShowWidgetDetails?: () => boolean;
+    getInlinePanelView?: () => "preview" | "console" | null;
+    setInlinePanelView?: (view: "preview" | "console" | null) => void;
+    hasValidPreview?: () => boolean;
+    getPreviewIframe?: () => HTMLIFrameElement | null;
+    getCurrentRepositoryId?: () => string | null;
+    setCurrentRepositoryId?: (repoId: string | null) => void;
+    setDirectPreviewUrl?: (url: string | null) => void;
+    setIframeSrc?: (src: string | null) => void;
+    setPreviewHasRuntimeError?: (val: boolean) => void;
+    setPreviewRuntimeErrorStatus?: (val: number | null) => void;
+    setHasAutoOpenedPreview?: (val: boolean) => void;
+    setPreviewLoadingState?: (val: boolean) => void;
+    getPreviewError?: () => string | null;
+    setPreviewBuildError?: (message: string | null) => void;
+    showNoCodeYetState?: () => void;
+    startPreviewLoadingPublic?: () => void;
+    sendMessageToPreview?: (message: Record<string, unknown>) => void;
+    setPreviewDimensions?: (width: number, height: number) => void;
+    getPreviewDimensions?: () => {
+        width: number;
+        height: number;
+    };
+    setupPreviewFallbackTimeoutPublic?: () => void;
+    startTokenAutoRefreshPublic?: () => void;
+    fetchDirectPreviewUrlPublic?: () => Promise<string | null>;
+    centerDetailsPanel?: () => void;
+    openWidgetDetails?: () => void;
+    closeWidgetDetails?: (options?: {
+        silent?: boolean;
+    }) => void;
+}, {
+    widgetRename: CustomEvent<any>;
+    fixErrors: CustomEvent<any>;
+    retryRepository: CustomEvent<any>;
+    generateNow: CustomEvent<any>;
+    fixCompileError: CustomEvent<any>;
+    stepChange: CustomEvent<any>;
+    previewLoaded: CustomEvent<any>;
+    buildFromRepoSuccess: CustomEvent<any>;
+    widgetReady: CustomEvent<any>;
+    widgetDataChanged: CustomEvent<any>;
+    buildFromRepoFailed: CustomEvent<any>;
+    previewCompileErrorChanged: CustomEvent<any>;
+    previewReady: CustomEvent<any>;
+    generateCode: CustomEvent<any>;
+    saveWidget: CustomEvent<any>;
+    widgetDetailsToggle: CustomEvent<any>;
+    focusPanel: CustomEvent<any>;
+    stateSync: CustomEvent<any>;
+} & {
+    [evt: string]: CustomEvent<any>;
+}, {
+    'code-generation': {};
+    'publish-widget': {};
+    'composition-editor': {};
+    'embed-section': {};
+}, {
+    beginCompositionHydration: () => void;
+    finishCompositionHydration: () => void;
+    markCodegenPreviewFresh: () => void;
+    hasLiveWorkerPreview: () => boolean;
+    getLatestRuntimeLogs: (maxLines?: number) => string[];
+    resumeDeferredPreviewLoad: () => Promise<void>;
+    loadWidget: (widgetId: string | null) => Promise<void>;
+    invalidatePublishedArtifactCache: () => void;
+    refreshPreview: (opts?: {
+        withRetry?: boolean;
+        skipIfAlreadyShowing?: boolean;
+    }) => Promise<void>;
+    triggerBuildFromRepo: (options?: {
+        force?: boolean;
+    }) => Promise<void>;
+    enqueueAction: (action: {
+        type: "generate";
+        prompt: string;
+    } | {
+        type: "save";
+    }) => void;
+    getShowWidgetDetails: () => boolean;
+    getInlinePanelView: () => "preview" | "console" | null;
+    setInlinePanelView: (view: "preview" | "console" | null) => void;
+    hasValidPreview: () => boolean;
+    getPreviewIframe: () => HTMLIFrameElement | null;
+    getCurrentRepositoryId: () => string | null;
+    setCurrentRepositoryId: (repoId: string | null) => void;
+    setDirectPreviewUrl: (url: string | null) => void;
+    setIframeSrc: (src: string | null) => void;
+    setPreviewHasRuntimeError: (val: boolean) => void;
+    setPreviewRuntimeErrorStatus: (val: number | null) => void;
+    setHasAutoOpenedPreview: (val: boolean) => void;
+    setPreviewLoadingState: (val: boolean) => void;
+    getPreviewError: () => string | null;
+    setPreviewBuildError: (message: string | null) => void;
+    showNoCodeYetState: () => void;
+    startPreviewLoadingPublic: () => void;
+    sendMessageToPreview: (message: Record<string, unknown>) => void;
+    setPreviewDimensions: (width: number, height: number) => void;
+    getPreviewDimensions: () => {
+        width: number;
+        height: number;
+    };
+    setupPreviewFallbackTimeoutPublic: () => void;
+    startTokenAutoRefreshPublic: () => void;
+    fetchDirectPreviewUrlPublic: () => Promise<string | null>;
+    centerDetailsPanel: () => void;
+    openWidgetDetails: () => void;
+    closeWidgetDetails: (options?: {
+        silent?: boolean;
+    }) => void;
+}, string>;
+type WidgetDetails = InstanceType<typeof WidgetDetails>;
+export default WidgetDetails;

package/dist/components/index.js

@@ -0,0 +1,4 @@
+// export local Svelte components
+// import Toolbar from './Toolbar.svelte';
+// import StylePanel from './StylePanel.svelte';
+// export { Toolbar, StylePanel };

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const maxCharsFromId = 12;

package/dist/constants.js

@@ -0,0 +1 @@
+export const maxCharsFromId = 12;

package/dist/creator-types.d.ts

@@ -0,0 +1,64 @@
+export interface CreatorAppProps {
+    canvasId?: string | null;
+    projectId?: string | null;
+    workspaceType?: 'personal' | 'organization';
+    organizationId?: string | null;
+    initialWidgetId?: string | null;
+    /** Select this composition when opening Edit step from site. */
+    initialCompositionId?: string | null;
+    /** Open Widget Details on this step when embedded from site (overrides auto step once). */
+    initialStep?: 'create' | 'edit' | 'embed';
+    /**
+     * Site "+ New widget": create an empty canvas + Untitled widget instead of
+     * restoring the last project canvas / selected widget.
+     */
+    forceCreateNewWidget?: boolean;
+    /** When true, hides auth screen + top bar; syncs session from site localStorage */
+    embedded?: boolean;
+    /**
+     * API gateway origin for embedded hosts (e.g. site `PUBLIC_API_URL`).
+     * Without this, production creator dist falls back to SDK default `dev-api.widgetic.com`.
+     */
+    apiUrl?: string | null;
+    /**
+     * Widget Builder Worker origin (e.g. site `PUBLIC_WIDGET_BUILDER_URL`).
+     * Used for preview probes / iframe when not going through the Vite same-origin proxy.
+     */
+    widgetBuilderUrl?: string | null;
+    /**
+     * Host-controlled debug UI (Planner/Coder dropdowns + toggle).
+     * When set, this prop is the source of truth — do not bake debug into creator-app.js.
+     * `true` = show debug UI and start ON. `false` = hide debug UI.
+     * Omit for standalone widget-creator (falls back to VITE_DEBUG_MODE / dev).
+     */
+    initialDebugMode?: boolean;
+    /**
+     * Host-controlled default coder model id (e.g. `deepseek-v4-flash`).
+     * Site reads its own env and passes this — no creator-app.js rebuild, no API-gateway default for the UI.
+     */
+    defaultCoderModelId?: string | null;
+    /** Host-controlled default planner model id (e.g. `openai-gpt-5.5`). */
+    defaultPlannerModelId?: string | null;
+    /**
+     * Floating Widgets List panel (debug UI). Default true so standalone Creator
+     * still shows it when Debug is ON. Site passes false — My widgets lives in the host.
+     */
+    showWidgetsList?: boolean;
+    /**
+     * Opt-in Dexie L1 (`@widgetic/cache-layer`). Default false.
+     * Site `/canvas` and the standalone creator host pass true so drafts / canvas
+     * fallbacks persist per user. When false, setCacheOwner is never called.
+     */
+    enableLocalCache?: boolean;
+    class?: string;
+    style?: string;
+    onPublishComplete?: (detail: {
+        widgetId: string;
+        version?: number;
+    }) => void;
+    onBack?: () => void;
+    onWidgetRenamed?: (detail: {
+        widgetId: string;
+        name: string;
+    }) => void;
+}

package/dist/creator-types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { default as CreatorApp } from './CreatorApp.svelte';
+export type { CreatorAppProps } from './creator-types.js';
+export { syncSessionFromSiteAuth } from './syncSiteAuth.js';
+export { mount, unmount } from 'svelte';

package/dist/index.js

@@ -0,0 +1,5 @@
+export { default as CreatorApp } from './CreatorApp.svelte';
+export { syncSessionFromSiteAuth } from './syncSiteAuth.js';
+// Re-export so site hosts can mount the self-contained embed with the same
+// Svelte runtime that compiled CreatorApp (avoid dual-runtime crashes).
+export { mount, unmount } from 'svelte';

package/dist/localCacheGate.d.ts

@@ -0,0 +1,7 @@
+export declare function setEnableLocalCache(enabled: boolean): void;
+export declare function isLocalCacheEnabled(): boolean;
+/** Scope L1 to user when enabled; otherwise clear owner (creator-owned bundle only). */
+export declare function syncLocalCacheOwner(user: {
+    id?: string;
+    user_id?: string;
+} | null | undefined): void;

package/dist/localCacheGate.js

@@ -0,0 +1,29 @@
+import { clearCacheOwner, setCacheOwner } from '@widgetic/cache-layer';
+/**
+ * Gates Dexie L1 for the creator JS graph.
+ * Default off — host passes enableLocalCache={true} (site /canvas, standalone page).
+ */
+let enableLocalCache = false;
+export function setEnableLocalCache(enabled) {
+    enableLocalCache = !!enabled;
+    if (!enableLocalCache) {
+        clearCacheOwner();
+    }
+}
+export function isLocalCacheEnabled() {
+    return enableLocalCache;
+}
+/** Scope L1 to user when enabled; otherwise clear owner (creator-owned bundle only). */
+export function syncLocalCacheOwner(user) {
+    if (!enableLocalCache) {
+        clearCacheOwner();
+        return;
+    }
+    const ownerId = user?.id || user?.user_id || null;
+    if (ownerId) {
+        setCacheOwner(String(ownerId));
+    }
+    else {
+        clearCacheOwner();
+    }
+}

package/dist/pageHelpers.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Pure helper functions extracted from +page.svelte to reduce file size
+ * and prevent rollup AST recursion overflow during production builds.
+ */
+export declare function looksLikeHtmlErrorPage(raw: string | null | undefined): boolean;
+/** Cloudflare Worker / gateway HTML dumps must never appear in chat, preview, or Edit. */
+export declare function sanitizePreviewBuildError(raw: string | null | undefined): string;
+export declare function isInfrastructurePreviewError(raw: string | null | undefined): boolean;
+export declare function normalizeErrorMessage(rawError: string | Error | unknown): string;
+export declare function toErrorMessage(error: unknown, fallback: string): string;
+export declare function extractDetailsMessage(payload: unknown): string | null;
+export declare function deriveApiErrorMessage(error: unknown, defaultMessage: string): Promise<string>;
+export declare function decodeJWT(token: string): Record<string, unknown> | null;
+export declare function isTokenExpired(token: string): boolean;
+export declare function fileToBase64(file: File): Promise<string>;

package/dist/pageHelpers.js

@@ -0,0 +1,194 @@
+/**
+ * Pure helper functions extracted from +page.svelte to reduce file size
+ * and prevent rollup AST recursion overflow during production builds.
+ */
+import { ResponseError } from '@widgetic/api-sdk';
+// ===================== Error Handling Helpers =====================
+const HTML_ERROR_PAGE_RE = /^\s*(<!DOCTYPE\s+html|<html[\s>]|<!--\[if\s+lt\s+IE)/i;
+const CLOUDFLARE_ERROR_PAGE_RE = /<title>\s*Page not found\s*<\/title>|workers\.cloudflare|error code:\s*1042/i;
+export function looksLikeHtmlErrorPage(raw) {
+    if (!raw)
+        return false;
+    const text = raw.trim();
+    return text.length >= 12 && (HTML_ERROR_PAGE_RE.test(text) || CLOUDFLARE_ERROR_PAGE_RE.test(text));
+}
+/** Cloudflare Worker / gateway HTML dumps must never appear in chat, preview, or Edit. */
+export function sanitizePreviewBuildError(raw) {
+    const text = typeof raw === 'string' ? raw.trim() : '';
+    if (!text)
+        return 'Preview build failed.';
+    if (/failed to fetch|fetch failed/i.test(text)) {
+        return 'Could not reach the preview builder. Try Rebuild.';
+    }
+    if (looksLikeHtmlErrorPage(text) || /error code:\s*1042/i.test(text)) {
+        return 'Preview builder is unavailable. The widget code was saved — use Rebuild to compile it.';
+    }
+    if (text.length > 240 && /<\/?[a-z][\s\S]*>/i.test(text)) {
+        return 'Preview builder returned an unexpected error page. Try Rebuild.';
+    }
+    return text.length > 400 ? `${text.slice(0, 400)}…` : text;
+}
+export function isInfrastructurePreviewError(raw) {
+    if (!raw)
+        return false;
+    if (looksLikeHtmlErrorPage(raw))
+        return true;
+    return /preview builder is unavailable|could not reach the preview builder|unexpected error page/i.test(sanitizePreviewBuildError(raw));
+}
+export function normalizeErrorMessage(rawError) {
+    let extracted = '';
+    if (typeof rawError === 'string') {
+        extracted = rawError;
+    }
+    else if (!rawError) {
+        extracted = 'An unknown error occurred.';
+    }
+    else if (rawError instanceof Error && rawError.message) {
+        extracted = rawError.message;
+    }
+    else if (typeof rawError === 'object') {
+        const maybeMessage = rawError.message ||
+            rawError.details;
+        if (maybeMessage && maybeMessage.trim().length > 0) {
+            extracted = maybeMessage;
+        }
+        else {
+            try {
+                extracted = JSON.stringify(rawError);
+            }
+            catch (jsonError) {
+                console.warn('Failed to stringify error payload for toast.', {
+                    rawError,
+                    err: jsonError
+                });
+                extracted = 'An unknown error occurred.';
+            }
+        }
+    }
+    else {
+        extracted = String(rawError);
+    }
+    if (looksLikeHtmlErrorPage(extracted) || /error code:\s*1042/i.test(extracted)) {
+        return sanitizePreviewBuildError(extracted);
+    }
+    if (/failed to fetch|fetch failed/i.test(extracted)) {
+        return 'Could not reach the server. Try again.';
+    }
+    if (extracted.length > 240 && /<\/?[a-z][\s\S]*>/i.test(extracted)) {
+        return sanitizePreviewBuildError(extracted);
+    }
+    return extracted.length > 400 ? `${extracted.slice(0, 400)}…` : extracted;
+}
+export function toErrorMessage(error, fallback) {
+    if (error instanceof Error && error.message) {
+        return looksLikeHtmlErrorPage(error.message)
+            ? sanitizePreviewBuildError(error.message)
+            : error.message;
+    }
+    if (typeof error === 'string' && error.trim().length > 0) {
+        return looksLikeHtmlErrorPage(error) ? sanitizePreviewBuildError(error) : error;
+    }
+    return fallback;
+}
+export function extractDetailsMessage(payload) {
+    if (!payload) {
+        return null;
+    }
+    if (typeof payload === 'string') {
+        try {
+            const parsed = JSON.parse(payload);
+            return extractDetailsMessage(parsed);
+        }
+        catch {
+            return payload;
+        }
+    }
+    if (Array.isArray(payload)) {
+        for (const item of payload) {
+            const message = extractDetailsMessage(item);
+            if (message) {
+                return message;
+            }
+        }
+        return null;
+    }
+    if (typeof payload === 'object') {
+        const candidate = payload;
+        if (candidate.message && typeof candidate.message === 'string') {
+            return candidate.message;
+        }
+        if (candidate.error) {
+            return extractDetailsMessage(candidate.error);
+        }
+    }
+    return null;
+}
+export async function deriveApiErrorMessage(error, defaultMessage) {
+    const response = error instanceof ResponseError
+        ? error.response
+        : error?.response;
+    if (response) {
+        try {
+            const cloned = response.clone();
+            const payload = await cloned.json();
+            const derived = extractDetailsMessage(payload?.error ?? payload);
+            if (derived) {
+                return derived;
+            }
+        }
+        catch {
+            // ignore JSON parsing issues
+        }
+    }
+    return toErrorMessage(error, defaultMessage);
+}
+// ===================== JWT Helpers =====================
+export function decodeJWT(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3) {
+            throw new Error(`Invalid JWT format: expected 3 parts, got ${parts.length}`);
+        }
+        // Verify header parses
+        const header = parts[0];
+        const paddedHeader = header + '='.repeat((4 - (header.length % 4)) % 4);
+        JSON.parse(atob(paddedHeader));
+        // Decode payload
+        const payload = parts[1];
+        const paddedPayload = payload + '='.repeat((4 - (payload.length % 4)) % 4);
+        const decodedPayloadString = atob(paddedPayload);
+        if (!decodedPayloadString || decodedPayloadString.trim() === '') {
+            throw new Error('Empty payload in JWT');
+        }
+        return JSON.parse(decodedPayloadString);
+    }
+    catch (error) {
+        console.error('Failed to decode JWT:', error);
+        return null;
+    }
+}
+export function isTokenExpired(token) {
+    try {
+        const decoded = decodeJWT(token);
+        if (!decoded || !decoded.exp) {
+            console.warn('Token has no expiration field, considering it expired');
+            return true;
+        }
+        const currentTime = Math.floor(Date.now() / 1000);
+        return decoded.exp < currentTime;
+    }
+    catch (error) {
+        console.error('Error checking token expiration:', error);
+        return true;
+    }
+}
+// ===================== File/Image Helpers =====================
+export async function fileToBase64(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = reject;
+        reader.readAsDataURL(file);
+    });
+}
+// VM Session Helpers removed — VM infrastructure decommissioned

package/dist/stores/userSession.d.ts

@@ -0,0 +1,7 @@
+export declare const userSession: import("svelte/store").Writable<{
+    user: any;
+    jwt: any;
+}>;
+export declare function setSession(user: any, jwt: any): void;
+export declare function clearSession(): void;
+export declare function restoreSession(): void;

package/dist/stores/userSession.js

@@ -0,0 +1,32 @@
+import { writable } from 'svelte/store';
+import { syncLocalCacheOwner } from '../localCacheGate.js';
+export const userSession = writable({
+    user: null,
+    jwt: null
+});
+export function setSession(user, jwt) {
+    userSession.set({ user, jwt });
+    if (jwt)
+        localStorage.setItem('jwt', jwt);
+    if (user)
+        localStorage.setItem('user', JSON.stringify(user));
+    syncLocalCacheOwner(user);
+}
+export function clearSession() {
+    userSession.set({ user: null, jwt: null });
+    localStorage.removeItem('jwt');
+    localStorage.removeItem('user');
+    syncLocalCacheOwner(null);
+}
+export function restoreSession() {
+    const jwt = localStorage.getItem('jwt');
+    const userStr = localStorage.getItem('user');
+    let user = null;
+    try {
+        if (userStr)
+            user = JSON.parse(userStr);
+    }
+    catch { }
+    userSession.set({ user, jwt });
+    syncLocalCacheOwner(user);
+}

package/dist/stores/websocketStore.d.ts

@@ -0,0 +1,53 @@
+export interface DynamicWorkerPreviewStatus {
+    widgetId: string | null;
+    previewUrl: string | null;
+    buildTimeMs: number | null;
+    timestamp: string | null;
+}
+export interface WidgetPublishStatus {
+    widgetId: string | null;
+    status: 'success' | 'failure' | 'building' | null;
+    version?: number;
+    artifactUrl?: string;
+    message?: string;
+    error?: {
+        code?: string;
+        details?: string;
+    };
+    timestamp: string | null;
+}
+export interface CodeGenerationStatus {
+    operationId: string | null;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | null;
+    previousStatus: string | null;
+    progress: number;
+    error: string | null;
+    timestamp: string | null;
+}
+/** Agent harness repair lines pushed during codegen (vmConsole:aiderOutput). */
+export interface AgentHarnessOutput {
+    output: string;
+    timestamp: string;
+}
+interface ConnectionState {
+    connected: boolean;
+    joinedRooms: string[];
+    error: string | null;
+}
+export declare const connectionState: import("svelte/store").Writable<ConnectionState>;
+export declare const dynamicWorkerPreviewStatus: import("svelte/store").Writable<DynamicWorkerPreviewStatus>;
+export declare const widgetPublishStatus: import("svelte/store").Writable<WidgetPublishStatus>;
+export declare const codeGenerationStatus: import("svelte/store").Writable<CodeGenerationStatus>;
+export declare const agentHarnessOutput: import("svelte/store").Writable<AgentHarnessOutput>;
+export declare function setAuthToken(token: string | null): void;
+/** Prefer host-provided API URL so embedded creator does not socket.io to localhost:3000. */
+export declare function setWebsocketApiUrl(apiUrl: string | null | undefined): void;
+/**
+ * Connect to WebSocket and join user room for receiving events.
+ */
+export declare function connectWebSocket(userId?: string): Promise<boolean>;
+/**
+ * Disconnect from WebSocket.
+ */
+export declare function disconnectWebSocket(): Promise<void>;
+export {};