slexkit 0.2.0 → 0.3.1

package/dist/tooling.js

@@ -33811,6 +33811,49 @@ function list(value) {
 function emit(ctx, event2, data2) {
   ctx.emit(event2, data2);
 }
+function scheduleFrame(ctx, fn) {
+  const handle = { kind: "microtask", canceled: false };
+  const run3 = (time) => {
+    if (!handle.canceled)
+      fn(time);
+  };
+  const apiRaf = ctx.api?.raf;
+  if (typeof apiRaf === "function") {
+    try {
+      handle.kind = "api";
+      handle.id = apiRaf(run3);
+      return handle;
+    } catch {
+      handle.kind = "microtask";
+      handle.id = undefined;
+    }
+  }
+  const ownerWindow = ctx.document.defaultView;
+  if (ownerWindow && typeof ownerWindow.requestAnimationFrame === "function") {
+    try {
+      handle.kind = "native";
+      handle.id = ownerWindow.requestAnimationFrame(run3);
+      return handle;
+    } catch {
+      handle.kind = "microtask";
+      handle.id = undefined;
+    }
+  }
+  queueMicrotask(() => run3());
+  return handle;
+}
+function cancelScheduledFrame(ctx, handle) {
+  if (!handle || handle.canceled)
+    return;
+  handle.canceled = true;
+  if (handle.kind === "api" && typeof ctx.api?.cancelRaf === "function") {
+    try {
+      ctx.api.cancelRaf(handle.id);
+    } catch {}
+  } else if (handle.kind === "native" && typeof handle.id === "number") {
+    ctx.document.defaultView?.cancelAnimationFrame(handle.id);
+  }
+}
 function formatScriptKey(key2) {
   return /^[A-Za-z_$][\w$]*$/.test(key2) ? key2 : JSON.stringify(key2);
 }
@@ -34536,7 +34579,7 @@ function Select($$anchor, $$props) {
     set(open, false);
     set(activeIndex, selectedIndex(), true);
     if (focusTrigger)
-      requestAnimationFrame(() => get2(triggerEl)?.focus());
+      scheduleFrame($$props.ctx, () => get2(triggerEl)?.focus());
   }
   function toggle() {
     if (get2(open))
@@ -37507,14 +37550,13 @@ function Tabs2($$anchor, $$props) {
     };
   }
   function annotateTabs(node) {
-    let raf2;
+    let frame;
     let resizeObserver;
     let indicatorReady = false;
     function scheduleIndicatorUpdate(list3, selectedTrigger) {
-      if (raf2 !== undefined)
-        cancelAnimationFrame(raf2);
-      raf2 = requestAnimationFrame(() => {
-        raf2 = undefined;
+      cancelScheduledFrame($$props.ctx, frame);
+      frame = scheduleFrame($$props.ctx, () => {
+        frame = undefined;
         if (!selectedTrigger) {
           list3.style.setProperty("--slex-tabs-indicator-opacity", "0");
           return;
@@ -37541,7 +37583,7 @@ function Tabs2($$anchor, $$props) {
         list3.style.setProperty("--slex-tabs-indicator-opacity", "1");
         if (!indicatorReady) {
           indicatorReady = true;
-          requestAnimationFrame(() => {
+          scheduleFrame($$props.ctx, () => {
             list3.dataset.indicatorReady = "true";
           });
         }
@@ -37582,8 +37624,7 @@ function Tabs2($$anchor, $$props) {
         apply2();
       },
       destroy() {
-        if (raf2 !== undefined)
-          cancelAnimationFrame(raf2);
+        cancelScheduledFrame($$props.ctx, frame);
         resizeObserver?.disconnect();
       }
     };
@@ -58302,11 +58343,72 @@ function PlaygroundSlexCode($$anchor, $$props) {
 }
 
 // src/components/svelte/tooling/PlaygroundMarkdown.svelte
-var root105 = from_html(`<div class="slex-doc-streamdown"><!></div>`);
+var root105 = from_html(`<div class="slex-doc-prose slex-doc-streamdown"><!></div>`);
 function PlaygroundMarkdown($$anchor, $$props) {
   push($$props, true);
   const extensions = [markedKatex({ singleDollarInline: true })];
   const renderers = { inlineKatex: KatexRenderer, blockKatex: KatexRenderer };
+  const options = { headerIds: false };
+  function stripFrontmatter(value) {
+    const raw = String(value ?? "").replace(/^\uFEFF/, "").replace(/\r\n/g, `
+`);
+    if (!raw.startsWith("---"))
+      return raw;
+    const end = raw.indexOf(`
+---`, 3);
+    if (end === -1)
+      return raw;
+    const closeEnd = raw.indexOf(`
+`, end + 1);
+    return raw.slice(closeEnd === -1 ? raw.length : closeEnd + 1).trimStart();
+  }
+  function escapeHtml(value) {
+    return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  }
+  function stripInlineMarkdown(value) {
+    return String(value).replace(/\s+\{#[A-Za-z0-9_-]+\}\s*$/, "").replace(/`([^`]+)`/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/<[^>]+>/g, "").replace(/\s+#+\s*$/, "").trim();
+  }
+  function slugText(value) {
+    const slug2 = String(value).toLowerCase().replace(/[`"'\u2018\u2019\u201c\u201d]/g, "").replace(/[^a-z0-9\u4e00-\u9fa5]+/g, "-").replace(/^-+|-+$/g, "");
+    return slug2 || "section";
+  }
+  function createHeadingIdGenerator() {
+    const counts = new Map;
+    return (rawTitle) => {
+      const explicit = rawTitle.match(/\s+\{#([A-Za-z0-9_-]+)\}\s*$/)?.[1] ?? "";
+      const base2 = explicit || slugText(stripInlineMarkdown(rawTitle));
+      const count2 = counts.get(base2) ?? 0;
+      counts.set(base2, count2 + 1);
+      return count2 ? `${base2}-${count2 + 1}` : base2;
+    };
+  }
+  function normalizeHeadingAnchors(markdown2) {
+    const nextId = createHeadingIdGenerator();
+    let fence = null;
+    return String(markdown2 ?? "").split(/\n/).map((line) => {
+      const marker = String(line).match(/^[ \t]{0,3}(`{3,}|~{3,})/);
+      if (fence) {
+        if (marker && marker[1][0] === fence.char && marker[1].length >= fence.length)
+          fence = null;
+        return line;
+      }
+      if (marker) {
+        fence = { char: marker[1][0], length: marker[1].length };
+        return line;
+      }
+      const heading2 = String(line).match(/^(#{1,6})[ \t]+(.+)$/);
+      if (!heading2)
+        return line;
+      const rawTitle = heading2[2].replace(/\s+#+\s*$/, "");
+      const renderedTitle = rawTitle.replace(/\s+\{#[A-Za-z0-9_-]+\}\s*$/, "").trim();
+      return `<span id="${escapeHtml(nextId(rawTitle))}" class="slex-doc-heading-anchor"></span>
+${heading2[1]} ${renderedTitle}`;
+    }).join(`
+`);
+  }
+  function previewMarkdown(value) {
+    return normalizeHeadingAnchors(stripFrontmatter(value));
+  }
   var div = root105();
   var node = child(div);
   {
@@ -58325,9 +58427,10 @@ function PlaygroundMarkdown($$anchor, $$props) {
         }
       });
     };
+    let $0 = user_derived(() => previewMarkdown($$props.content));
     dist_default(node, {
       get source() {
-        return $$props.content;
+        return get2($0);
       },
       get extensions() {
         return extensions;
@@ -58335,6 +58438,9 @@ function PlaygroundMarkdown($$anchor, $$props) {
       get renderers() {
         return renderers;
       },
+      get options() {
+        return options;
+      },
       code: code2,
       $$slots: { code: true }
     });

package/dist/types/components/svelte/helpers.d.ts

@@ -18,7 +18,7 @@ export declare function itemLabel(item: unknown): string;
 export declare function itemDescription(item: unknown): string;
 export declare function readColumns(value: unknown): string[];
 export declare function readColumnLabel(column: unknown, fallback: string): string;
-export declare function readCell(row: unknown, column: string): string;
+export declare function readCell(row: unknown, column: string, index?: number): string;
 export declare function catalogItems(value: unknown): Record<string, unknown>[];
 export declare function catalogGroups(value: unknown): Array<{
     label: string;
@@ -28,6 +28,13 @@ export declare function renderChildren(node: HTMLElement, ctx: RenderContext): {
     destroy(): void;
 };
 export declare function emit(ctx: RenderContext, event: string, data?: unknown): void;
+export type ScheduledFrame = {
+    kind: "api" | "native" | "microtask";
+    id?: unknown;
+    canceled: boolean;
+};
+export declare function scheduleFrame(ctx: RenderContext, fn: (time?: number) => void): ScheduledFrame;
+export declare function cancelScheduledFrame(ctx: RenderContext, handle: ScheduledFrame | undefined): void;
 export declare function formatScriptValue(value: unknown, indent?: number): string;
 export declare function stringifySource(source: unknown): string;
 export {};

package/dist/types/engine/capabilities.d.ts

@@ -0,0 +1,54 @@
+export type SlexKitStdlibFunctionDoc = {
+    name: string;
+    signature: string;
+    summary: string;
+    pure: true;
+    example: string;
+};
+export type SlexKitStdlibNamespaceDoc = {
+    name: "math" | "stats" | "format" | "units";
+    summary: string;
+    functions: SlexKitStdlibFunctionDoc[];
+};
+export type SlexKitRuntimeCapabilityDoc = {
+    name: string;
+    policy: "network" | "timer" | "animation" | "canvas" | "lifecycle" | "diagnostics";
+    signature: string;
+    summary: string;
+    example: string;
+    secureDefault: "denied" | "available";
+    forbidden?: string[];
+};
+export declare const slexkitExpressionContext: readonly [{
+    readonly name: "g";
+    readonly scope: "always";
+    readonly summary: "Reactive state proxy.";
+}, {
+    readonly name: "std";
+    readonly scope: "always";
+    readonly summary: "Pure deterministic SlexKit standard library.";
+}, {
+    readonly name: "api";
+    readonly scope: "host-injected";
+    readonly summary: "Host or secure runtime capability object.";
+}, {
+    readonly name: "$event";
+    readonly scope: "event handlers";
+    readonly summary: "Event payload for on* handlers.";
+}, {
+    readonly name: "$item";
+    readonly scope: "$for";
+    readonly summary: "Current array item.";
+}, {
+    readonly name: "$index";
+    readonly scope: "$for";
+    readonly summary: "Current item index.";
+}, {
+    readonly name: "$key";
+    readonly scope: "$for";
+    readonly summary: "Current item key.";
+}];
+export declare const slexkitStdlibDocs: SlexKitStdlibNamespaceDoc[];
+export declare const slexkitRuntimeCapabilities: SlexKitRuntimeCapabilityDoc[];
+export declare const slexkitStdlibFunctionNames: string[];
+export declare const slexkitRuntimeCapabilityNames: string[];

package/dist/types/engine/index.d.ts

@@ -3,10 +3,16 @@ import type { SecureMountOptions } from "./secure-runtime";
 export { register, getRenderer } from "./registry";
 export { diagnoseSlexKitSource, SlexKitSyntaxError, formatSlexKitDiagnostic, parseSlexSource, parseSlexKitDsl, } from "./diagnostics";
 export type { SlexKitParseResult, SlexKitSourceDiagnostic } from "./diagnostics";
+export { validateSlexSource } from "./validation";
+export type { SlexKitValidationMode, SlexKitValidationOptions, SlexKitValidationResult, SlexKitValidationWarning, SlexKitValidationWarningCode, } from "./validation";
 export type { ComponentRegistrationOptions, ComponentRenderer, ComponentStateMode, MountOptions, RenderContext, SlexExpression, ThemeMode, 
 /** @deprecated Use SlexExpression instead. */
 DSL, } from "./types";
 export { createSecureRuntime, SlexKitRuntimeError, serializeRuntimeError, } from "./secure-runtime";
+export { slexkitStd } from "./stdlib";
+export type { SlexKitStdlib } from "./stdlib";
+export { slexkitExpressionContext, slexkitRuntimeCapabilities, slexkitRuntimeCapabilityNames, slexkitStdlibDocs, slexkitStdlibFunctionNames, } from "./capabilities";
+export type { SlexKitRuntimeCapabilityDoc, SlexKitStdlibFunctionDoc, SlexKitStdlibNamespaceDoc, } from "./capabilities";
 export { createSlexKitMarkdownRuntimeHost, getSlexKitMarkdownRuntimeHost, installSlexKitMarkdownRuntimeHost, } from "./markdown-runtime";
 export type { SlexKitMarkdownBlock, SlexKitMarkdownRuntimeHost, SlexKitMarkdownRuntimeMode, SlexKitMarkdownRuntimeOptions, } from "./markdown-runtime";
 export type { SlexKitRuntimeApi, HostFetchRequest, HostRuntimeAdapter, HostRuntimePolicy, NetworkOptions, NetworkResult, RafId, RuntimeCanvasContext, RuntimeCanvasContextId, RuntimeErrorEvent, RuntimeErrorKind, RuntimeNetworkLogEvent, SandboxSlotSizeMessage, SandboxSlotsMessage, SandboxFetchRequestMessage, SandboxFetchResponseMessage, SandboxHostMessage, SandboxMountMessage, SandboxRunnerMessage, SandboxStatusMessage, SecureFrameOptions, SecureArtifactSlot, SecureMountOptions, SecureRuntimeHandle, SerializedRuntimeError, TimerId, } from "./secure-runtime";

package/dist/types/engine/secure-runtime.d.ts

@@ -113,6 +113,7 @@ export type SecureFrameOptions = {
     sandbox?: string;
     unsafeAllowSameOrigin?: boolean;
     runtimeUrl?: string;
+    styleUrl?: string | false;
     loadTimeoutMs?: number;
     /**
      * @deprecated Use runtimeUrl. The runner is now shipped inside the main SlexKit runtime module.
@@ -186,6 +187,13 @@ export type SandboxSlotSizeMessage = {
     slotId: string;
     height: number;
 };
+export type SandboxFrameSizeMessage = {
+    channel: "slexkit-secure";
+    type: "frame-size";
+    id: string;
+    token: string;
+    height: number;
+};
 export type SandboxStatusMessage = {
     channel: "slexkit-secure";
     type: "ready" | "mounted" | "heartbeat" | "disposed" | "error";
@@ -194,7 +202,7 @@ export type SandboxStatusMessage = {
     error?: SerializedRuntimeError;
 };
 export type SandboxHostMessage = SandboxMountMessage | SandboxDisposeMessage | SandboxFetchResponseMessage | SandboxSlotsMessage;
-export type SandboxRunnerMessage = SandboxFetchRequestMessage | SandboxSlotSizeMessage | SandboxStatusMessage;
+export type SandboxRunnerMessage = SandboxFetchRequestMessage | SandboxFrameSizeMessage | SandboxSlotSizeMessage | SandboxStatusMessage;
 export type SerializedRuntimeError = {
     name: string;
     message: string;

package/dist/types/engine/stdlib.d.ts

@@ -0,0 +1,30 @@
+export type SlexKitStdlib = {
+    math: {
+        clamp: (value: unknown, min: unknown, max: unknown) => number;
+        round: (value: unknown, digits?: unknown) => number;
+        safeDivide: (numerator: unknown, denominator: unknown, fallback?: unknown) => number;
+        percent: (part: unknown, total: unknown, digits?: unknown) => number;
+        lerp: (start: unknown, end: unknown, t: unknown) => number;
+    };
+    stats: {
+        sum: (values: unknown) => number;
+        mean: (values: unknown) => number;
+        min: (values: unknown) => number;
+        max: (values: unknown) => number;
+        median: (values: unknown) => number;
+    };
+    format: {
+        fixed: (value: unknown, digits?: unknown) => string;
+        number: (value: unknown, digits?: unknown, locale?: unknown) => string;
+        compact: (value: unknown, digits?: unknown, locale?: unknown) => string;
+        percent: (ratio: unknown, digits?: unknown) => string;
+        currency: (value: unknown, currency?: unknown, locale?: unknown) => string;
+    };
+    units: {
+        withUnit: (value: unknown, unit: unknown, digits?: unknown) => string;
+        bytes: (value: unknown, digits?: unknown) => string;
+        duration: (ms: unknown, digits?: unknown) => string;
+        si: (value: unknown, unit?: unknown, digits?: unknown) => string;
+    };
+};
+export declare const slexkitStd: SlexKitStdlib;

package/dist/types/engine/types.d.ts

@@ -46,6 +46,7 @@ export type MountOptions = {
 };
 export type RenderContext = {
     g: Record<string, unknown>;
+    std: import("./stdlib").SlexKitStdlib;
     api?: Record<string, unknown>;
     dir: Exclude<DirectionMode, "auto">;
     labels: RuntimeLabels;

package/dist/types/engine/validation.d.ts

@@ -0,0 +1,28 @@
+import { type SlexKitSourceDiagnostic } from "./diagnostics";
+export type SlexKitValidationMode = "trusted" | "secure";
+export type SlexKitValidationWarningCode = "unknown_component" | "unknown_prop" | "unknown_std_member" | "unknown_api_member" | "native_secure_capability";
+export type SlexKitValidationWarning = {
+    code: SlexKitValidationWarningCode;
+    message: string;
+    path?: string;
+    value?: string;
+};
+export type SlexKitValidationOptions = {
+    mode?: SlexKitValidationMode;
+};
+export type SlexKitValidationResult = {
+    ok: true;
+    value: unknown;
+    warnings: SlexKitValidationWarning[];
+    componentUsage: string[];
+    stdlibUsage: string[];
+    apiUsage: string[];
+} | {
+    ok: false;
+    diagnostic: SlexKitSourceDiagnostic;
+    warnings: SlexKitValidationWarning[];
+    componentUsage: string[];
+    stdlibUsage: string[];
+    apiUsage: string[];
+};
+export declare function validateSlexSource(source: string, options?: SlexKitValidationOptions): SlexKitValidationResult;

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-import { mount, ingest, boot, disposeNamespace, register, getRenderer, diagnoseSlexKitSource, SlexKitSyntaxError, formatSlexKitDiagnostic, mountSecureArtifact, parseSlexSource, createSecureRuntime, SlexKitRuntimeError, getSlexKitRuntimeUrl, setSlexKitRuntimeUrl, createSlexKitMarkdownRuntimeHost, getSlexKitMarkdownRuntimeHost, installSlexKitMarkdownRuntimeHost } from "./engine/index";
+import { mount, ingest, boot, disposeNamespace, register, getRenderer, diagnoseSlexKitSource, SlexKitSyntaxError, formatSlexKitDiagnostic, mountSecureArtifact, parseSlexSource, validateSlexSource, createSecureRuntime, SlexKitRuntimeError, getSlexKitRuntimeUrl, setSlexKitRuntimeUrl, createSlexKitMarkdownRuntimeHost, getSlexKitMarkdownRuntimeHost, installSlexKitMarkdownRuntimeHost } from "./engine/index";
 import { registerAll, registerSvelteComponent, registerSubset } from "./components/index";
 import { renderToolCall, registerToolTemplate } from "./toolhost/index";
 import { startSlexKitSandboxRunner } from "./engine/sandbox-runner";
@@ -17,6 +17,7 @@ declare const formatSlexKitDiagnosticApi: typeof formatSlexKitDiagnostic;
 declare const mountSecureArtifactApi: typeof mountSecureArtifact;
 declare const parseSlexSourceApi: typeof parseSlexSource;
 declare const parseSlexKitDslApi: typeof parseSlexSource;
+declare const validateSlexSourceApi: typeof validateSlexSource;
 declare const createSecureRuntimeApi: typeof createSecureRuntime;
 declare const SlexKitRuntimeErrorApi: typeof SlexKitRuntimeError;
 declare const getSlexKitRuntimeUrlApi: typeof getSlexKitRuntimeUrl;
@@ -24,6 +25,7 @@ declare const setSlexKitRuntimeUrlApi: typeof setSlexKitRuntimeUrl;
 declare const createSlexKitMarkdownRuntimeHostApi: typeof createSlexKitMarkdownRuntimeHost;
 declare const getSlexKitMarkdownRuntimeHostApi: typeof getSlexKitMarkdownRuntimeHost;
 declare const installSlexKitMarkdownRuntimeHostApi: typeof installSlexKitMarkdownRuntimeHost;
+declare const slexkitStdApi: import(".").SlexKitStdlib;
 declare const registerAllApi: typeof registerAll;
 declare const registerSvelteComponentApi: typeof registerSvelteComponent;
 declare const registerSubsetApi: typeof registerSubset;
@@ -43,10 +45,11 @@ declare const resolveIconWeightApi: typeof resolveIconWeight;
 declare const attachComponentDisposerApi: typeof attachComponentDisposer;
 declare const configureComponentScopeApi: typeof configureComponentScope;
 declare const getSlexKitInfoApi: typeof getSlexKitInfo;
-export { SLEXKIT_VERSION, SLEX_PROTOCOL_VERSION, SLEXKIT_COMPONENTS_VERSION, getSlexKitInfoApi as getSlexKitInfo, mountApi as mount, ingestApi as ingest, bootApi as boot, disposeNamespaceApi as disposeNamespace, registerApi as register, getRendererApi as getRenderer, diagnoseSlexKitSourceApi as diagnoseSlexKitSource, SlexKitSyntaxErrorApi as SlexKitSyntaxError, formatSlexKitDiagnosticApi as formatSlexKitDiagnostic, mountSecureArtifactApi as mountSecureArtifact, parseSlexSourceApi as parseSlexSource, parseSlexKitDslApi as parseSlexKitDsl, createSecureRuntimeApi as createSecureRuntime, SlexKitRuntimeErrorApi as SlexKitRuntimeError, getSlexKitRuntimeUrlApi as getSlexKitRuntimeUrl, setSlexKitRuntimeUrlApi as setSlexKitRuntimeUrl, createSlexKitMarkdownRuntimeHostApi as createSlexKitMarkdownRuntimeHost, getSlexKitMarkdownRuntimeHostApi as getSlexKitMarkdownRuntimeHost, installSlexKitMarkdownRuntimeHostApi as installSlexKitMarkdownRuntimeHost, };
+export { SLEXKIT_VERSION, SLEX_PROTOCOL_VERSION, SLEXKIT_COMPONENTS_VERSION, getSlexKitInfoApi as getSlexKitInfo, mountApi as mount, ingestApi as ingest, bootApi as boot, disposeNamespaceApi as disposeNamespace, registerApi as register, getRendererApi as getRenderer, diagnoseSlexKitSourceApi as diagnoseSlexKitSource, SlexKitSyntaxErrorApi as SlexKitSyntaxError, formatSlexKitDiagnosticApi as formatSlexKitDiagnostic, mountSecureArtifactApi as mountSecureArtifact, parseSlexSourceApi as parseSlexSource, parseSlexKitDslApi as parseSlexKitDsl, validateSlexSourceApi as validateSlexSource, createSecureRuntimeApi as createSecureRuntime, SlexKitRuntimeErrorApi as SlexKitRuntimeError, getSlexKitRuntimeUrlApi as getSlexKitRuntimeUrl, setSlexKitRuntimeUrlApi as setSlexKitRuntimeUrl, createSlexKitMarkdownRuntimeHostApi as createSlexKitMarkdownRuntimeHost, getSlexKitMarkdownRuntimeHostApi as getSlexKitMarkdownRuntimeHost, installSlexKitMarkdownRuntimeHostApi as installSlexKitMarkdownRuntimeHost, slexkitStdApi as slexkitStd, };
 export type { BootOptions } from "./engine/index";
 export type { SlexKitParseResult, SlexKitSourceDiagnostic } from "./engine/index";
-export type { SlexKitRuntimeApi, HostFetchRequest, HostRuntimeAdapter, HostRuntimePolicy, NetworkOptions, NetworkResult, RafId, RuntimeCanvasContext, RuntimeCanvasContextId, RuntimeErrorEvent, RuntimeErrorKind, RuntimeNetworkLogEvent, SandboxSlotSizeMessage, SandboxSlotsMessage, SandboxFetchRequestMessage, SandboxFetchResponseMessage, SandboxHostMessage, SandboxMountMessage, SandboxRunnerMessage, SandboxStatusMessage, SecureFrameOptions, SecureArtifactSlot, SecureMountOptions, SecureRuntimeHandle, SerializedRuntimeError, TimerId, } from "./engine/index";
+export type { SlexKitValidationMode, SlexKitValidationOptions, SlexKitValidationResult, SlexKitValidationWarning, SlexKitValidationWarningCode, } from "./engine/index";
+export type { SlexKitRuntimeApi, HostFetchRequest, HostRuntimeAdapter, HostRuntimePolicy, NetworkOptions, NetworkResult, RafId, RuntimeCanvasContext, RuntimeCanvasContextId, RuntimeErrorEvent, RuntimeErrorKind, RuntimeNetworkLogEvent, SandboxSlotSizeMessage, SandboxSlotsMessage, SandboxFetchRequestMessage, SandboxFetchResponseMessage, SandboxHostMessage, SandboxMountMessage, SandboxRunnerMessage, SandboxStatusMessage, SecureFrameOptions, SecureArtifactSlot, SecureMountOptions, SecureRuntimeHandle, SerializedRuntimeError, TimerId, SlexKitStdlib, } from "./engine/index";
 export type { SlexKitMarkdownBlock, SlexKitMarkdownRuntimeHost, SlexKitMarkdownRuntimeMode, SlexKitMarkdownRuntimeOptions, } from "./engine/index";
 export type { ComponentRenderer, RenderContext, SlexExpression, DSL } from "./engine/types";
 export { registerAllApi as registerAll, registerSvelteComponentApi as registerSvelteComponent, registerSubsetApi as registerSubset, };

package/dist/types/runtime.d.ts

@@ -1,10 +1,11 @@
-import { mount, ingest, boot, disposeNamespace, register, getRenderer, diagnoseSlexKitSource, SlexKitSyntaxError, formatSlexKitDiagnostic, mountSecureArtifact, parseSlexSource, createSecureRuntime, SlexKitRuntimeError, getSlexKitRuntimeUrl, setSlexKitRuntimeUrl, createSlexKitMarkdownRuntimeHost, getSlexKitMarkdownRuntimeHost, installSlexKitMarkdownRuntimeHost } from "./engine/index";
+import { mount, ingest, boot, disposeNamespace, register, getRenderer, diagnoseSlexKitSource, SlexKitSyntaxError, formatSlexKitDiagnostic, mountSecureArtifact, parseSlexSource, validateSlexSource, createSecureRuntime, SlexKitRuntimeError, getSlexKitRuntimeUrl, setSlexKitRuntimeUrl, createSlexKitMarkdownRuntimeHost, getSlexKitMarkdownRuntimeHost, installSlexKitMarkdownRuntimeHost } from "./engine/index";
 import { attachComponentDisposer, configureComponentScope } from "./engine/component-scope";
 import { startSlexKitSandboxRunner } from "./engine/sandbox-runner";
 import { getSlexKitInfo, SLEXKIT_COMPONENTS_VERSION, SLEXKIT_VERSION, SLEX_PROTOCOL_VERSION } from "./version";
 export type { BootOptions } from "./engine/index";
 export type { SlexKitParseResult, SlexKitSourceDiagnostic } from "./engine/index";
-export type { ComponentRenderer, ComponentRegistrationOptions, ComponentStateMode, RenderContext, SlexExpression, DSL, SlexKitRuntimeApi, HostFetchRequest, HostRuntimeAdapter, HostRuntimePolicy, NetworkOptions, NetworkResult, RafId, RuntimeCanvasContext, RuntimeCanvasContextId, RuntimeErrorEvent, RuntimeErrorKind, RuntimeNetworkLogEvent, SandboxSlotSizeMessage, SandboxSlotsMessage, SandboxFetchRequestMessage, SandboxFetchResponseMessage, SandboxHostMessage, SandboxMountMessage, SandboxRunnerMessage, SandboxStatusMessage, SecureFrameOptions, SecureArtifactSlot, SecureMountOptions, SecureRuntimeHandle, SerializedRuntimeError, TimerId, } from "./engine/index";
+export type { SlexKitValidationMode, SlexKitValidationOptions, SlexKitValidationResult, SlexKitValidationWarning, SlexKitValidationWarningCode, } from "./engine/index";
+export type { ComponentRenderer, ComponentRegistrationOptions, ComponentStateMode, RenderContext, SlexExpression, DSL, SlexKitRuntimeApi, HostFetchRequest, HostRuntimeAdapter, HostRuntimePolicy, NetworkOptions, NetworkResult, RafId, RuntimeCanvasContext, RuntimeCanvasContextId, RuntimeErrorEvent, RuntimeErrorKind, RuntimeNetworkLogEvent, SandboxSlotSizeMessage, SandboxSlotsMessage, SandboxFetchRequestMessage, SandboxFetchResponseMessage, SandboxHostMessage, SandboxMountMessage, SandboxRunnerMessage, SandboxStatusMessage, SecureFrameOptions, SecureArtifactSlot, SecureMountOptions, SecureRuntimeHandle, SerializedRuntimeError, TimerId, SlexKitStdlib, } from "./engine/index";
 export type { SlexKitMarkdownBlock, SlexKitMarkdownRuntimeHost, SlexKitMarkdownRuntimeMode, SlexKitMarkdownRuntimeOptions, } from "./engine/index";
 declare const mountApi: typeof mount;
 declare const ingestApi: typeof ingest;
@@ -18,6 +19,7 @@ declare const formatSlexKitDiagnosticApi: typeof formatSlexKitDiagnostic;
 declare const mountSecureArtifactApi: typeof mountSecureArtifact;
 declare const parseSlexSourceApi: typeof parseSlexSource;
 declare const parseSlexKitDslApi: typeof parseSlexSource;
+declare const validateSlexSourceApi: typeof validateSlexSource;
 declare const createSecureRuntimeApi: typeof createSecureRuntime;
 declare const SlexKitRuntimeErrorApi: typeof SlexKitRuntimeError;
 declare const getSlexKitRuntimeUrlApi: typeof getSlexKitRuntimeUrl;
@@ -25,8 +27,9 @@ declare const setSlexKitRuntimeUrlApi: typeof setSlexKitRuntimeUrl;
 declare const createSlexKitMarkdownRuntimeHostApi: typeof createSlexKitMarkdownRuntimeHost;
 declare const getSlexKitMarkdownRuntimeHostApi: typeof getSlexKitMarkdownRuntimeHost;
 declare const installSlexKitMarkdownRuntimeHostApi: typeof installSlexKitMarkdownRuntimeHost;
+declare const slexkitStdApi: import(".").SlexKitStdlib;
 declare const attachComponentDisposerApi: typeof attachComponentDisposer;
 declare const configureComponentScopeApi: typeof configureComponentScope;
 declare const startSlexKitSandboxRunnerApi: typeof startSlexKitSandboxRunner;
 declare const getSlexKitInfoApi: typeof getSlexKitInfo;
-export { SLEXKIT_VERSION, SLEX_PROTOCOL_VERSION, SLEXKIT_COMPONENTS_VERSION, getSlexKitInfoApi as getSlexKitInfo, mountApi as mount, ingestApi as ingest, bootApi as boot, disposeNamespaceApi as disposeNamespace, registerApi as register, getRendererApi as getRenderer, diagnoseSlexKitSourceApi as diagnoseSlexKitSource, SlexKitSyntaxErrorApi as SlexKitSyntaxError, formatSlexKitDiagnosticApi as formatSlexKitDiagnostic, mountSecureArtifactApi as mountSecureArtifact, parseSlexSourceApi as parseSlexSource, parseSlexKitDslApi as parseSlexKitDsl, createSecureRuntimeApi as createSecureRuntime, SlexKitRuntimeErrorApi as SlexKitRuntimeError, getSlexKitRuntimeUrlApi as getSlexKitRuntimeUrl, setSlexKitRuntimeUrlApi as setSlexKitRuntimeUrl, createSlexKitMarkdownRuntimeHostApi as createSlexKitMarkdownRuntimeHost, getSlexKitMarkdownRuntimeHostApi as getSlexKitMarkdownRuntimeHost, installSlexKitMarkdownRuntimeHostApi as installSlexKitMarkdownRuntimeHost, attachComponentDisposerApi as attachComponentDisposer, configureComponentScopeApi as configureComponentScope, startSlexKitSandboxRunnerApi as startSlexKitSandboxRunner, };
+export { SLEXKIT_VERSION, SLEX_PROTOCOL_VERSION, SLEXKIT_COMPONENTS_VERSION, getSlexKitInfoApi as getSlexKitInfo, mountApi as mount, ingestApi as ingest, bootApi as boot, disposeNamespaceApi as disposeNamespace, registerApi as register, getRendererApi as getRenderer, diagnoseSlexKitSourceApi as diagnoseSlexKitSource, SlexKitSyntaxErrorApi as SlexKitSyntaxError, formatSlexKitDiagnosticApi as formatSlexKitDiagnostic, mountSecureArtifactApi as mountSecureArtifact, parseSlexSourceApi as parseSlexSource, parseSlexKitDslApi as parseSlexKitDsl, validateSlexSourceApi as validateSlexSource, createSecureRuntimeApi as createSecureRuntime, SlexKitRuntimeErrorApi as SlexKitRuntimeError, getSlexKitRuntimeUrlApi as getSlexKitRuntimeUrl, setSlexKitRuntimeUrlApi as setSlexKitRuntimeUrl, createSlexKitMarkdownRuntimeHostApi as createSlexKitMarkdownRuntimeHost, getSlexKitMarkdownRuntimeHostApi as getSlexKitMarkdownRuntimeHost, installSlexKitMarkdownRuntimeHostApi as installSlexKitMarkdownRuntimeHost, slexkitStdApi as slexkitStd, attachComponentDisposerApi as attachComponentDisposer, configureComponentScopeApi as configureComponentScope, startSlexKitSandboxRunnerApi as startSlexKitSandboxRunner, };

package/dist/types/version.d.ts

@@ -1,6 +1,6 @@
-export declare const SLEXKIT_VERSION = "0.2.0";
+export declare const SLEXKIT_VERSION = "0.3.1";
 export declare const SLEX_PROTOCOL_VERSION = "0.1";
-export declare const SLEXKIT_COMPONENTS_VERSION = "0.2.0";
+export declare const SLEXKIT_COMPONENTS_VERSION = "0.3.1";
 export declare function getSlexKitInfo(): {
     version: string;
     protocolVersion: string;