@syntrologie/runtime-sdk 2.8.0-canary.13 → 2.8.0-canary.130

package/README.md

@@ -1,5 +1,7 @@
 # Smart Canvas Runtime SDK
 
+> Config is delivered via GrowthBook feature flags — discovered automatically, no hardcoded keys.
+
 ## Runtime SDK (React + Shadow DOM)
 
 The SDK ships a framework-agnostic `<smart-canvas>` custom element with an **open shadow root**. We render everything with React, but the canvas is encapsulated so host Tailwind configs, resets, or stacking contexts can't break the UI.
@@ -513,3 +515,4 @@ The telemetry client emits:
 4. Configure the SDK with your API credentials
 5. Use `runtime.actions` for interventions, `runtime.surfaces` for UI
 6. For non-React pages, call `window.SmartCanvas.create()` with configuration
+

package/dist/SmartCanvasApp.d.ts

@@ -2,6 +2,7 @@ import { type ReactNode } from 'react';
 import type { BatchActionHandle } from './actions/types';
 import type { SmartCanvasController } from './controller';
 import type { ExperimentClient } from './experiments/types';
+import type { PlatformAdapter } from './platform/PlatformAdapter';
 import type { SmartCanvasRuntime } from './runtime';
 import type { TelemetryClient } from './telemetry/types';
 import type { CanvasThemeConfig } from './theme';
@@ -34,5 +35,7 @@ export interface SmartCanvasAppProps {
     initialBatchHandle?: BatchActionHandle | null;
     /** Workspace-level theme for 3-layer inheritance (defaults → workspace → config) */
     workspaceTheme?: CanvasThemeConfig;
+    /** Platform adapter for host-platform-specific integrations (Shopify, WordPress, etc.) */
+    platformAdapter?: PlatformAdapter;
 }
-export declare function SmartCanvasApp({ controller, fetcher, configUri, configUriFeatureKey, configFeatureKey, fetchCredentials, pollIntervalMs, experiments, telemetry, runtime, overlayFetcher, overlayConfigUri, overlayConfigFeatureKey, overlayFetchCredentials, footerSlot, launcherLabel, canvasHost, initialBatchHandle, workspaceTheme, }: SmartCanvasAppProps): import("react/jsx-runtime").JSX.Element;
+export declare function SmartCanvasApp({ controller, fetcher, configUri, configUriFeatureKey, configFeatureKey, fetchCredentials, pollIntervalMs, experiments, telemetry, runtime, overlayFetcher, overlayConfigUri, overlayConfigFeatureKey, overlayFetchCredentials, footerSlot, launcherLabel, canvasHost, initialBatchHandle, workspaceTheme, platformAdapter, }: SmartCanvasAppProps): import("react/jsx-runtime").JSX.Element;

package/dist/SmartCanvasElementLit.d.ts

@@ -0,0 +1,166 @@
+/**
+ * SmartCanvasElementLit — LitElement shell for the Smart Canvas SDK.
+ *
+ * This is the Lit equivalent of SmartCanvasElement.tsx (raw HTMLElement + React).
+ * It absorbs the logic from SmartCanvasApp.tsx directly into the element class:
+ *   - Config fetching (useShadowCanvasConfig equivalent)
+ *   - Action lifecycle (batch handle, revert/apply, version counter)
+ *   - Theme via ThemeController
+ *   - Canvas open/close via SmartCanvasController
+ *   - Runtime context via @lit/context
+ *
+ * Renders <syntro-canvas-overlay> as its main child (Lit component).
+ *
+ * Decorator-free: uses `static override properties` (tsconfig has no
+ * experimentalDecorators).
+ */
+import { LitElement, nothing } from 'lit';
+import type { BatchActionHandle } from './actions/types.js';
+import './components/SyntroCanvasOverlay.js';
+import { type SmartCanvasController } from './controller.js';
+import type { ExperimentClient } from './experiments/types.js';
+import './interop/ReactInLit.js';
+import type { SmartCanvasRuntime } from './runtime.js';
+import type { TelemetryClient } from './telemetry/types.js';
+import type { ActionStep, CanvasConfigFetcher, CanvasThemeConfig, LauncherConfig, TileConfig } from './types.js';
+export declare const runtimeContext: {
+    __context__: SmartCanvasRuntime | null;
+};
+/**
+ * Props accepted by mountLitApp(). Mirrors SmartCanvasAppProps minus controller
+ * (the element owns the controller) and footerSlot/canvasHost (React-only).
+ */
+export interface SmartCanvasLitProps {
+    fetcher?: CanvasConfigFetcher;
+    configUri?: string;
+    configUriFeatureKey?: string;
+    configFeatureKey?: string;
+    fetchCredentials?: RequestCredentials;
+    experiments?: ExperimentClient;
+    telemetry?: TelemetryClient;
+    runtime?: SmartCanvasRuntime;
+    launcherLabel?: string;
+    initialBatchHandle?: BatchActionHandle | null;
+    workspaceTheme?: CanvasThemeConfig;
+}
+export declare class SmartCanvasElementLit extends LitElement {
+    #private;
+    static shadowRootOptions: ShadowRootInit;
+    static styles: import("lit").CSSResult;
+    static properties: {
+        fetcher: {
+            attribute: boolean;
+        };
+        configUri: {
+            type: StringConstructor;
+        };
+        configUriFeatureKey: {
+            type: StringConstructor;
+        };
+        configFeatureKey: {
+            type: StringConstructor;
+        };
+        fetchCredentials: {
+            type: StringConstructor;
+        };
+        experiments: {
+            attribute: boolean;
+        };
+        telemetry: {
+            attribute: boolean;
+        };
+        runtime: {
+            attribute: boolean;
+        };
+        launcherLabel: {
+            type: StringConstructor;
+        };
+        initialBatchHandle: {
+            attribute: boolean;
+        };
+        workspaceTheme: {
+            attribute: boolean;
+        };
+        _tiles: {
+            state: boolean;
+        };
+        _configActions: {
+            state: boolean;
+        };
+        _isLoading: {
+            state: boolean;
+        };
+        _error: {
+            state: boolean;
+        };
+        _theme: {
+            state: boolean;
+        };
+        _launcher: {
+            state: boolean;
+        };
+        _canvasTitle: {
+            state: boolean;
+        };
+        _displayMode: {
+            state: boolean;
+        };
+        _isOpen: {
+            state: boolean;
+        };
+        _pageUrl: {
+            state: boolean;
+        };
+    };
+    fetcher: CanvasConfigFetcher | undefined;
+    configUri: string | undefined;
+    configUriFeatureKey: string | undefined;
+    configFeatureKey: string | undefined;
+    fetchCredentials: RequestCredentials;
+    experiments: ExperimentClient | undefined;
+    telemetry: TelemetryClient | undefined;
+    runtime: SmartCanvasRuntime | undefined;
+    launcherLabel: string | undefined;
+    initialBatchHandle: BatchActionHandle | null;
+    workspaceTheme: CanvasThemeConfig | undefined;
+    /** @internal */ _tiles: TileConfig[];
+    /** @internal */ _configActions: ActionStep[];
+    /** @internal */ _isLoading: boolean;
+    /** @internal */ _error: string | undefined;
+    /** @internal */ _theme: CanvasThemeConfig | undefined;
+    /** @internal */ _launcher: LauncherConfig | undefined;
+    /** @internal */ _canvasTitle: string | undefined;
+    /** @internal */ _displayMode: 'standard' | 'focused';
+    /** @internal */ _isOpen: boolean;
+    /** @internal */ _pageUrl: string;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    updated(changed: Map<string, unknown>): void;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    setOverrideFetcher(fetcher: CanvasConfigFetcher): void;
+    getMountNode(): HTMLElement;
+    getController(): SmartCanvasController;
+    /** React portal target inside shadow root (launcher, drawer, toasts) */
+    getPortalRoot(): HTMLDivElement | null;
+    /** Vanilla JS overlay container inside shadow root (tooltips, modals, spotlights) */
+    getOverlayContainer(): HTMLDivElement | null;
+    /** Direct access to the shadow root (for style injection) */
+    getShadowRoot(): ShadowRoot;
+    /**
+     * Mount the React-based SmartCanvasApp inside this element's shadow root.
+     * Uses the ReactBridge interop element. During the transition period, callers
+     * can use either mountReactApp() (React) or mountLitApp() (Lit).
+     */
+    mountReactApp(appProps: Record<string, unknown>): void;
+    /**
+     * Set properties directly on the element. The Lit property change triggers
+     * re-render and re-fetch without React.
+     */
+    mountLitApp(props: SmartCanvasLitProps): void;
+    _loadConfig(): Promise<void>;
+}
+export declare const registerSmartCanvasElement: () => void;