slexkit 0.2.0

package/dist/runtime.js

@@ -0,0 +1,3686 @@
+// src/engine/reactive.ts
+var ITERATE_KEY = Symbol("iterate");
+var REVISION_KEY = Symbol("revision");
+var activeEffect = null;
+var activeScope = null;
+var batchDepth = 0;
+var pendingEffects = new Set;
+var targetDeps = new WeakMap;
+var proxyCache = new WeakMap;
+var rawTargets = new WeakMap;
+var rootTargets = new WeakMap;
+
+class ReactiveScope {
+  cleanups = [];
+  effects = new Set;
+  disposed = false;
+  dispose() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    for (const effect of Array.from(this.effects))
+      effect.stop();
+    this.effects.clear();
+    for (let i = this.cleanups.length - 1;i >= 0; i -= 1) {
+      this.cleanups[i]();
+    }
+    this.cleanups.length = 0;
+  }
+}
+
+class ReactiveEffect {
+  fn;
+  scope;
+  deps = [];
+  cleanups = [];
+  stopped = false;
+  running = false;
+  constructor(fn, scope) {
+    this.fn = fn;
+    this.scope = scope;
+    if (scope)
+      scope.effects.add(this);
+  }
+  run() {
+    if (this.stopped || this.running)
+      return;
+    this.running = true;
+    this.cleanupDeps();
+    this.runCleanups();
+    const previousEffect = activeEffect;
+    const previousScope = activeScope;
+    activeEffect = this;
+    if (this.scope)
+      activeScope = this.scope;
+    try {
+      this.fn();
+    } finally {
+      activeEffect = previousEffect;
+      activeScope = previousScope;
+      this.running = false;
+    }
+  }
+  stop() {
+    if (this.stopped)
+      return;
+    this.stopped = true;
+    this.cleanupDeps();
+    this.runCleanups();
+    this.scope?.effects.delete(this);
+  }
+  cleanupDeps() {
+    for (const dep of this.deps)
+      dep.delete(this);
+    this.deps.length = 0;
+  }
+  runCleanups() {
+    for (let i = this.cleanups.length - 1;i >= 0; i -= 1) {
+      this.cleanups[i]();
+    }
+    this.cleanups.length = 0;
+  }
+}
+function getDep(target, key) {
+  let deps = targetDeps.get(target);
+  if (!deps) {
+    deps = new Map;
+    targetDeps.set(target, deps);
+  }
+  let dep = deps.get(key);
+  if (!dep) {
+    dep = new Set;
+    deps.set(key, dep);
+  }
+  return dep;
+}
+function track(target, key) {
+  if (!activeEffect)
+    return;
+  const dep = getDep(target, key);
+  if (dep.has(activeEffect))
+    return;
+  dep.add(activeEffect);
+  activeEffect.deps.push(dep);
+}
+function trigger(target, key) {
+  const deps = targetDeps.get(target);
+  if (!deps)
+    return;
+  const effects = new Set;
+  const add = (dep) => {
+    if (!dep)
+      return;
+    for (const effect of dep)
+      effects.add(effect);
+  };
+  add(deps.get(key));
+  if (key !== REVISION_KEY)
+    add(deps.get(ITERATE_KEY));
+  for (const effect of effects)
+    schedule(effect);
+}
+function schedule(effect) {
+  if (effect.stopped)
+    return;
+  if (batchDepth > 0) {
+    pendingEffects.add(effect);
+    return;
+  }
+  effect.run();
+}
+function flush() {
+  while (pendingEffects.size > 0) {
+    const effects = Array.from(pendingEffects);
+    pendingEffects.clear();
+    for (const effect of effects)
+      effect.run();
+  }
+}
+function notifyRoot(target) {
+  const root = rootTargets.get(target) ?? target;
+  trigger(root, REVISION_KEY);
+}
+function toReactive(value, root) {
+  const cached = proxyCache.get(value);
+  if (cached)
+    return cached;
+  const proxy = new Proxy(value, {
+    get(target, key, receiver) {
+      if (key === "__slexkitRaw")
+        return target;
+      if (key === "__slexkitRoot")
+        return root;
+      track(target, key);
+      const result = Reflect.get(target, key, receiver);
+      if (result && typeof result === "object") {
+        return toReactive(result, root);
+      }
+      return result;
+    },
+    set(target, key, next, receiver) {
+      const previous = Reflect.get(target, key, receiver);
+      const hadKey = Object.prototype.hasOwnProperty.call(target, key);
+      const ok = Reflect.set(target, key, next, receiver);
+      if (ok && (!Object.is(previous, next) || !hadKey)) {
+        trigger(target, key);
+        if (!hadKey)
+          trigger(target, ITERATE_KEY);
+        notifyRoot(target);
+      }
+      return ok;
+    },
+    deleteProperty(target, key) {
+      const hadKey = Object.prototype.hasOwnProperty.call(target, key);
+      const ok = Reflect.deleteProperty(target, key);
+      if (ok && hadKey) {
+        trigger(target, key);
+        trigger(target, ITERATE_KEY);
+        notifyRoot(target);
+      }
+      return ok;
+    },
+    ownKeys(target) {
+      track(target, ITERATE_KEY);
+      return Reflect.ownKeys(target);
+    }
+  });
+  proxyCache.set(value, proxy);
+  rawTargets.set(proxy, value);
+  rootTargets.set(value, root);
+  rootTargets.set(proxy, root);
+  return proxy;
+}
+function createReactiveState(value) {
+  return toReactive(value, value);
+}
+function asReactiveValue(value, owner) {
+  if (!value || typeof value !== "object")
+    return value;
+  if (rawTargets.has(value) || rootTargets.has(value))
+    return value;
+  if (!owner || typeof owner !== "object")
+    return value;
+  const root = rootTargets.get(owner) ?? rawTargets.get(owner);
+  if (!root)
+    return value;
+  return toReactive(value, root);
+}
+function trackReactiveValue(value) {
+  if (!value || typeof value !== "object")
+    return;
+  const root = rootTargets.get(value) ?? rawTargets.get(value);
+  if (root)
+    track(root, REVISION_KEY);
+}
+function createRoot(fn) {
+  const scope = new ReactiveScope;
+  const previousScope = activeScope;
+  const previousEffect = activeEffect;
+  activeScope = scope;
+  activeEffect = null;
+  try {
+    return fn(() => scope.dispose());
+  } finally {
+    activeEffect = previousEffect;
+    activeScope = previousScope;
+  }
+}
+function createEffect(fn) {
+  const effect = new ReactiveEffect(fn, activeScope);
+  effect.run();
+  return () => effect.stop();
+}
+function createMemo(fn) {
+  const source = {};
+  let value;
+  createEffect(() => {
+    value = fn();
+    trigger(source, "value");
+  });
+  return () => {
+    track(source, "value");
+    return value;
+  };
+}
+function createSignal(initial) {
+  const source = {};
+  let value = initial;
+  return [
+    () => {
+      track(source, "value");
+      return value;
+    },
+    (next) => {
+      if (Object.is(value, next))
+        return;
+      value = next;
+      trigger(source, "value");
+    }
+  ];
+}
+function onCleanup(cleanup) {
+  if (activeEffect) {
+    activeEffect.cleanups.push(cleanup);
+    return;
+  }
+  if (activeScope) {
+    activeScope.cleanups.push(cleanup);
+  }
+}
+function batch(fn) {
+  batchDepth += 1;
+  try {
+    return fn();
+  } finally {
+    batchDepth -= 1;
+    if (batchDepth === 0)
+      flush();
+  }
+}
+
+// src/engine/store.ts
+var _stores = new Map;
+function getStore(ns) {
+  if (!_stores.has(ns)) {
+    _stores.set(ns, {
+      g: createReactiveState({}),
+      components: createReactiveState({}),
+      componentTypes: createReactiveState({}),
+      layouts: [],
+      roots: new Map,
+      cleanups: new Map
+    });
+  }
+  return _stores.get(ns);
+}
+function peekStore(ns) {
+  return _stores.get(ns);
+}
+function deleteStore(ns) {
+  return _stores.delete(ns);
+}
+
+// src/engine/merge.ts
+function deepMerge(target, source) {
+  for (const key in source) {
+    if (!Object.prototype.hasOwnProperty.call(source, key))
+      continue;
+    const srcVal = source[key];
+    if (typeof srcVal === "function") {
+      target[key] = srcVal;
+    } else if (srcVal !== null && typeof srcVal === "object" && !Array.isArray(srcVal)) {
+      if (!(key in target) || typeof target[key] !== "object") {
+        target[key] = {};
+      }
+      deepMerge(target[key], srcVal);
+    } else {
+      target[key] = srcVal;
+    }
+  }
+  return target;
+}
+
+// src/engine/registry.ts
+var _registry = new Map;
+function register(type, renderFn, options = {}) {
+  _registry.set(type, {
+    renderFn,
+    options: {
+      state: options.state ?? "none"
+    }
+  });
+}
+function getRenderer(type) {
+  return _registry.get(type)?.renderFn;
+}
+function getComponentStateMode(type) {
+  return _registry.get(type)?.options.state ?? "none";
+}
+
+// src/engine/eval.ts
+var lastValues = new Map;
+var SKIP_EAGER_TRACK = Symbol.for("slexkit.skipEagerTrack");
+var EAGER_TRACK_TARGET = Symbol.for("slexkit.eagerTrackTarget");
+function clearEvalCache(ns) {
+  const prefix = `${ns}:`;
+  for (const key of Array.from(lastValues.keys())) {
+    if (key.startsWith(prefix))
+      lastValues.delete(key);
+  }
+}
+function evalRead(expr, context, ns, path) {
+  try {
+    for (const value of Object.values(context)) {
+      if (value && (typeof value === "object" || typeof value === "function") && value[SKIP_EAGER_TRACK]) {
+        continue;
+      }
+      const target = value && (typeof value === "object" || typeof value === "function") ? value[EAGER_TRACK_TARGET] ?? value : value;
+      trackReactiveValue(target);
+    }
+    const revision = context.$revision;
+    if (typeof revision === "function")
+      revision();
+    const keys = Object.keys(context);
+    const vals = Object.values(context);
+    const fn = new Function(...keys, `"use strict"; return (${expr});`);
+    const result = fn(...vals);
+    if (path !== undefined)
+      lastValues.set(`${ns ?? "?"}:${path}:${expr}`, result);
+    return result;
+  } catch (e) {
+    const cacheKey = path !== undefined ? `${ns ?? "?"}:${path}:${expr}` : expr;
+    const last = lastValues.get(cacheKey);
+    console.warn(`[SlexKit][${ns || "?"}] $eval error at ${path || "?"}:`, expr, e.message);
+    if (last !== undefined)
+      return last;
+    return;
+  }
+}
+function execWrite(stmt, context, ns, path) {
+  try {
+    const keys = Object.keys(context);
+    const vals = Object.values(context);
+    const fn = new Function(...keys, `"use strict"; { ${stmt} }`);
+    batch(() => fn(...vals));
+  } catch (e) {
+    console.warn(`[SlexKit][${ns || "?"}] @exec error at ${path || "?"}:`, stmt, e.message);
+  }
+}
+
+// src/engine/component-scope.ts
+var componentDisposers = new WeakMap;
+var flushDom;
+function configureComponentScope(options) {
+  flushDom = options.flush;
+}
+function createComponentAccessor(read) {
+  const subscribers = new Set;
+  let current = read();
+  const accessor = () => current;
+  accessor.subscribe = (run) => {
+    subscribers.add(run);
+    run(current);
+    const stop = createEffect(() => {
+      current = read();
+      for (const subscriber of subscribers)
+        subscriber(current);
+      flushDom?.();
+    });
+    return () => {
+      subscribers.delete(run);
+      stop();
+    };
+  };
+  return accessor;
+}
+function renderComponent(render) {
+  return render() ?? null;
+}
+function attachComponentDisposer(el, dispose) {
+  componentDisposers.set(el, dispose);
+}
+function disposeComponent(el) {
+  const dispose = componentDisposers.get(el);
+  if (!dispose)
+    return;
+  componentDisposers.delete(el);
+  dispose();
+}
+
+// src/engine/engineering.ts
+var NUMBER_RE = /^[+-]?(?:(?:\d+(?:\.\d*)?)|(?:\.\d+))(?:[eE][+-]?\d+)?/;
+var PREFIX_FACTORS = {
+  p: 0.000000000001,
+  n: 0.000000001,
+  u: 0.000001,
+  "µ": 0.000001,
+  m: 0.001,
+  k: 1000,
+  K: 1000,
+  M: 1e6,
+  meg: 1e6,
+  G: 1e9,
+  T: 1000000000000
+};
+var PREFIXES = ["meg", "p", "n", "u", "µ", "m", "k", "K", "M", "G", "T"];
+function invalid(raw, error) {
+  return {
+    raw,
+    number: null,
+    valid: false,
+    prefix: "",
+    unit: "",
+    normalized: "",
+    error
+  };
+}
+function parseSuffix(suffix) {
+  const compact = suffix.trim();
+  if (!compact)
+    return { prefix: "", unit: "" };
+  for (const prefix of PREFIXES) {
+    if (prefix === "meg") {
+      if (compact.toLowerCase().startsWith("meg")) {
+        return { prefix: "meg", unit: compact.slice(3).trim() };
+      }
+      continue;
+    }
+    if (compact.startsWith(prefix)) {
+      return { prefix, unit: compact.slice(prefix.length).trim() };
+    }
+  }
+  return { prefix: "", unit: compact };
+}
+function parseEngineeringNumber(input) {
+  const raw = input == null ? "" : String(input);
+  const source = raw.trim();
+  if (!source) {
+    return {
+      raw,
+      number: null,
+      valid: false,
+      prefix: "",
+      unit: "",
+      normalized: "",
+      error: "empty"
+    };
+  }
+  const numberMatch = source.match(NUMBER_RE);
+  if (!numberMatch)
+    return invalid(raw, "invalid_number");
+  const numberText = numberMatch[0];
+  const rest = source.slice(numberText.length).trim();
+  const base = Number(numberText);
+  if (!Number.isFinite(base))
+    return invalid(raw, "invalid_number");
+  const { prefix, unit } = parseSuffix(rest);
+  const multiplier = prefix ? PREFIX_FACTORS[prefix] : 1;
+  if (!Number.isFinite(multiplier))
+    return invalid(raw, "invalid_prefix");
+  const number = base * multiplier;
+  if (!Number.isFinite(number))
+    return invalid(raw, "out_of_range");
+  return {
+    raw,
+    number,
+    valid: true,
+    prefix,
+    unit,
+    normalized: `${number}${unit ? ` ${unit}` : ""}`
+  };
+}
+function isEngineeringNumberResult(value) {
+  return !!value && typeof value === "object" && "raw" in value && "number" in value && "valid" in value && "prefix" in value && "unit" in value && "normalized" in value;
+}
+
+// src/engine/component-state.ts
+var IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+var componentStateProxies = new WeakMap;
+function isReadableValue(value) {
+  return !!value && (typeof value === "object" || typeof value === "function") && typeof value.subscribe === "function";
+}
+function rawRecord(value) {
+  return value.__slexkitRaw ?? value;
+}
+function componentPropName(key) {
+  return key.startsWith("$") ? key.slice(1) : key;
+}
+function isEventProp(key, value) {
+  return key.startsWith("on") && typeof value === "function";
+}
+function isWritableComponent(type) {
+  const mode = getComponentStateMode(type);
+  return mode === "value" || mode === "checked" || mode === "enabled";
+}
+function isStatefulComponent(type) {
+  return getComponentStateMode(type) !== "none";
+}
+function isInputStateProp(type, propName) {
+  const mode = getComponentStateMode(type);
+  if (mode === "value")
+    return propName === "value";
+  if (mode === "checked")
+    return propName === "value" || propName === "checked";
+  if (mode === "enabled")
+    return propName === "enabled";
+  return false;
+}
+function assignEngineeringState(state, value) {
+  const result = isEngineeringNumberResult(value) ? value : parseEngineeringNumber(value);
+  state.value = result.raw;
+  state.number = result.number;
+  state.valid = result.valid;
+  state.prefix = result.prefix;
+  state.unit = result.unit;
+  state.normalized = result.normalized;
+  if (result.error)
+    state.error = result.error;
+  else
+    delete state.error;
+}
+function clearEngineeringState(state) {
+  delete state.number;
+  delete state.valid;
+  delete state.prefix;
+  delete state.unit;
+  delete state.normalized;
+  delete state.error;
+}
+function assignInputType(state, inputType) {
+  const previousType = state.type;
+  state.type = inputType;
+  if (inputType === "engineering" && "value" in state) {
+    assignEngineeringState(state, state.value);
+  } else if (previousType === "engineering" && inputType !== "engineering") {
+    clearEngineeringState(state);
+  }
+}
+function assignComponentProp(state, type, propName, value, force) {
+  if (!force && propName in state)
+    return;
+  if (type === "input" && propName === "value" && state.type === "engineering") {
+    assignEngineeringState(state, value);
+    return;
+  }
+  if (getComponentStateMode(type) === "checked" && (propName === "checked" || propName === "value")) {
+    const checked = !!value;
+    state.checked = checked;
+    state.value = checked;
+    return;
+  }
+  if (getComponentStateMode(type) === "enabled" && propName === "enabled") {
+    state.enabled = !!value;
+    return;
+  }
+  state[propName] = value;
+}
+function publicComponentState(name, state, componentTypes) {
+  let cached = componentStateProxies.get(state);
+  if (!cached) {
+    cached = new Proxy(state, {
+      get(target, key, receiver) {
+        if (key === SKIP_EAGER_TRACK)
+          return true;
+        return Reflect.get(target, key, receiver);
+      },
+      set(target, key, value, receiver) {
+        const currentType = componentTypes[name] ?? "";
+        if (isWritableComponent(currentType)) {
+          if (typeof key === "string") {
+            assignComponentProp(target, currentType, key, value, true);
+            return true;
+          }
+          return Reflect.set(target, key, value, receiver);
+        }
+        console.warn(`[SlexKit] Component state '${name}' is read-only. Use dynamic $ props to update output components.`);
+        return true;
+      },
+      deleteProperty(target, key) {
+        if (isWritableComponent(componentTypes[name] ?? "")) {
+          return Reflect.deleteProperty(target, key);
+        }
+        console.warn(`[SlexKit] Component state '${name}' is read-only. Use dynamic $ props to update output components.`);
+        return true;
+      }
+    });
+    componentStateProxies.set(state, cached);
+  }
+  return cached;
+}
+function createGProxy(g, components, componentTypes) {
+  return new Proxy(g, {
+    get(target, key, receiver) {
+      if (key === EAGER_TRACK_TARGET)
+        return target;
+      if (typeof key === "string" && !(key in target) && key in components) {
+        return publicComponentState(key, components[key], componentTypes);
+      }
+      return Reflect.get(target, key, receiver);
+    },
+    set(target, key, value, receiver) {
+      return Reflect.set(target, key, value, receiver);
+    },
+    has(target, key) {
+      return key in target || key in components;
+    }
+  });
+}
+function ensureComponentState(name, type, components, componentTypes) {
+  if (!components[name])
+    components[name] = {};
+  componentTypes[name] = type;
+  return components[name];
+}
+function syncReadableComponentProp(type, state, propName, value) {
+  if (isWritableComponent(type)) {
+    const unsubscribe2 = value.subscribe((next) => {
+      assignComponentProp(state, type, propName, next, true);
+    });
+    onCleanup(unsubscribe2);
+    return;
+  }
+  let unsubscribe;
+  let cancelled = false;
+  queueMicrotask(() => {
+    if (cancelled)
+      return;
+    unsubscribe = value.subscribe((next) => {
+      assignComponentProp(state, type, propName, next, true);
+    });
+  });
+  onCleanup(() => {
+    cancelled = true;
+    unsubscribe?.();
+  });
+}
+function syncComponentProps(type, name, props, components, componentTypes) {
+  if (!name || !isStatefulComponent(type))
+    return;
+  const state = ensureComponentState(name, type, components, componentTypes);
+  if (type === "input" && typeof props.type === "string") {
+    assignInputType(state, props.type);
+  }
+  for (const [key, value] of Object.entries(props)) {
+    if (isEventProp(key, value))
+      continue;
+    const propName = componentPropName(key);
+    const inputStateProp = isInputStateProp(type, propName);
+    if (isReadableValue(value)) {
+      syncReadableComponentProp(type, state, propName, value);
+    } else {
+      assignComponentProp(state, type, propName, value, !inputStateProp);
+    }
+  }
+  return state;
+}
+function bindInputStateProps(type, state, props) {
+  if (!state)
+    return;
+  const mode = getComponentStateMode(type);
+  if (mode === "value") {
+    props.value = createComponentAccessor(() => state.value);
+  } else if (mode === "checked") {
+    const checked = createComponentAccessor(() => !!(state.checked ?? state.value));
+    props.checked = checked;
+    props.value = checked;
+  } else if (mode === "enabled") {
+    props.enabled = createComponentAccessor(() => !!state.enabled);
+  }
+}
+function applyComponentEventState(type, name, data, components, componentTypes) {
+  if (!name || !isWritableComponent(type))
+    return;
+  const state = ensureComponentState(name, type, components, componentTypes);
+  const mode = getComponentStateMode(type);
+  if (mode === "checked") {
+    const checked = !!data;
+    state.checked = checked;
+    state.value = checked;
+  } else if (mode === "enabled") {
+    state.enabled = !!data;
+  } else if (type === "input" && state.type === "engineering") {
+    assignEngineeringState(state, data);
+  } else {
+    state.value = data;
+  }
+}
+function seedStaticComponentState(type, state, props) {
+  if (type === "input" && typeof props.type === "string") {
+    assignInputType(state, props.type);
+  }
+  for (const [key, value] of Object.entries(props)) {
+    if (key.startsWith("$") || isEventProp(key, value))
+      continue;
+    const propName = componentPropName(key);
+    if (isInputStateProp(type, propName)) {
+      assignComponentProp(state, type, propName, value, false);
+    }
+  }
+}
+function warnDuplicateState(ns, name, currentType, currentPath, previous) {
+  console.warn(`[SlexKit][${ns}] Component state '${name}' is declared more than once at ${previous.path} and ${currentPath}; state is shared by namespace and component name.`);
+  if (previous.type !== currentType) {
+    console.warn(`[SlexKit][${ns}] Component state '${name}' is used by multiple component types (${previous.type}, ${currentType}); the latest rendered type controls write behavior.`);
+  }
+}
+function warnForState(ns, name, path) {
+  console.warn(`[SlexKit][${ns}] Component state '${name}' is used with $for at ${path}; repeated items share one namespace-level instance state.`);
+}
+function prepareComponentStatesInner(layout, components, componentTypes, ns, seen, parentPath = "") {
+  if (!layout || typeof layout !== "object")
+    return;
+  for (const [key, val] of Object.entries(layout)) {
+    if (!key.includes(":") || typeof val !== "object" || val === null)
+      continue;
+    const [type, name] = key.split(":");
+    const props = val;
+    const path = parentPath ? `${parentPath}.${key}` : key;
+    if (name && isStatefulComponent(type)) {
+      const previous = seen.get(name);
+      if (previous)
+        warnDuplicateState(ns, name, type, path, previous);
+      else
+        seen.set(name, { type, path });
+      if (props.$for && isWritableComponent(type))
+        warnForState(ns, name, path);
+      const state = ensureComponentState(name, type, components, componentTypes);
+      seedStaticComponentState(type, state, props);
+    }
+    prepareComponentStatesInner(props, components, componentTypes, ns, seen, path);
+  }
+}
+function prepareComponentStates(layout, components, componentTypes, ns) {
+  prepareComponentStatesInner(layout, components, componentTypes, ns, new Map);
+}
+function buildComponentEvalContext(g, components, componentTypes, api, forCtx) {
+  const ctx = { g: createGProxy(g, components, componentTypes) };
+  for (const name of Object.keys(rawRecord(components))) {
+    if (IDENTIFIER.test(name)) {
+      ctx[name] = publicComponentState(name, components[name], componentTypes);
+    }
+  }
+  if (api)
+    ctx.api = api;
+  if (forCtx) {
+    for (const k of Object.keys(forCtx)) {
+      Object.defineProperty(ctx, k, {
+        get: () => {
+          const current = forCtx[k];
+          return k === "$index" && typeof current === "function" ? current() : current;
+        },
+        enumerable: true
+      });
+    }
+  }
+  return ctx;
+}
+
+// src/engine/renderer.ts
+var FALLBACK_CSS = "background:var(--muted);border:1px solid var(--border);border-radius:calc(var(--radius) - 2px);padding:0.5rem;text-align:center;font-size:0.75rem;color:var(--muted-foreground)";
+var defaultRenderOptions = {
+  dir: "ltr",
+  labels: {}
+};
+function hasComponentKey(obj) {
+  return Object.keys(obj).some((k) => k.includes(":"));
+}
+function separatePropsAndChildren(obj, props, children) {
+  for (const [k, v] of Object.entries(obj)) {
+    if (k === "$if" || k === "$for" || k === "$key")
+      continue;
+    if (k.includes(":") || typeof v === "object" && v !== null && Object.keys(v).length > 0 && hasComponentKey(v)) {
+      children[k] = v;
+    } else {
+      props[k] = v;
+    }
+  }
+}
+function callHook(g, name, type) {
+  const key = name ? `${type}_${name}` : `${type}_`;
+  const fn = g[key];
+  if (typeof fn === "function") {
+    fn.call(g);
+  }
+}
+function applyEnterAnimation(el, props) {
+  const enterFn = props.$enter;
+  if (typeof enterFn !== "function")
+    return;
+  const animClass = enterFn();
+  if (animClass && typeof animClass === "string") {
+    el.classList.add(animClass);
+    el.addEventListener("animationend", () => el.classList.remove(animClass), { once: true });
+  }
+}
+function applyLeaveAnimation(el, props, callback) {
+  const leaveFn = props.$leave;
+  if (typeof leaveFn !== "function") {
+    callback();
+    return;
+  }
+  const animClass = leaveFn();
+  if (animClass && typeof animClass === "string") {
+    el.classList.add(animClass);
+    el.addEventListener("animationend", () => {
+      callback();
+    }, { once: true });
+  } else {
+    callback();
+  }
+}
+function renderWithFallback(renderer, props, name, ctx, fullKey, ns) {
+  try {
+    return renderComponent(() => renderer(props, name, ctx));
+  } catch (e) {
+    console.warn(`[SlexKit][${ns}] Render error at ${fullKey}:`, e.message);
+    const fb = (ctx.document || document).createElement("div");
+    fb.className = "slex-render-error";
+    fb.title = fullKey;
+    fb.setAttribute("style", FALLBACK_CSS);
+    return fb;
+  }
+}
+function resolveDynamicProps(props, g, components, componentTypes, api, forCtx, ns, fullKey) {
+  const evalCtx = buildComponentEvalContext(g, components, componentTypes, api, forCtx);
+  for (const [k, v] of Object.entries(props)) {
+    if (k.startsWith("$") && !k.startsWith("$if") && !k.startsWith("$for") && !k.startsWith("$key") && typeof v === "string") {
+      const path = `${fullKey}:${k}`;
+      const memo = createMemo(() => evalRead(v, evalCtx, ns, path));
+      props[k] = createComponentAccessor(memo);
+    } else if (k.startsWith("on") && typeof v === "string") {
+      const stmt = v;
+      const path = `${fullKey}:${k}`;
+      props[k] = ($event) => execWrite(stmt, { ...evalCtx, $event: $event ?? null }, ns, path);
+    }
+  }
+}
+function resolveKeyValue(item, itemIndex, $keyProp) {
+  if ($keyProp) {
+    if ($keyProp === "$value") {
+      return item;
+    }
+    if ($keyProp === "id" || $keyProp !== "id" && item && typeof item === "object") {
+      return item?.[$keyProp];
+    }
+  }
+  if (item && typeof item === "object" && "id" in item) {
+    return item.id;
+  }
+  const primitiveTypes = ["string", "number", "boolean"];
+  if (primitiveTypes.includes(typeof item)) {
+    console.warn("[SlexKit] $for with primitive array items but no $key specified. Use '$key: $value' for primitive arrays. Falling back to index.");
+    return itemIndex;
+  }
+  console.warn("[SlexKit] $for array item has no 'id' property and no $key specified. Falling back to index.");
+  return itemIndex;
+}
+function trackForCollection(value) {
+  if (!Array.isArray(value))
+    return value;
+  Reflect.get(value, "length");
+  for (const item of value) {
+    if (item && typeof item === "object") {
+      for (const key of Object.keys(item)) {
+        Reflect.get(item, key);
+      }
+    }
+  }
+  return value;
+}
+function renderIfNode(fullKey, props, container, g, components, componentTypes, api, forCtx, ns, options) {
+  const [type, name] = fullKey.split(":");
+  const renderer = getRenderer(type);
+  if (!renderer)
+    return;
+  const evalCtx = buildComponentEvalContext(g, components, componentTypes, api, forCtx);
+  const show = createMemo(() => evalRead(props.$if, evalCtx, ns, `${fullKey}:$if`));
+  let current = null;
+  const leavingInstances = new Set;
+  let mounting = false;
+  let emit;
+  const disposeInstance = (instance) => {
+    if (instance.disposed)
+      return;
+    instance.disposed = true;
+    leavingInstances.delete(instance);
+    if (current === instance)
+      current = null;
+    disposeComponent(instance.el);
+    instance.dispose();
+    callHook(g, name, "onUnmount");
+    instance.el.remove();
+  };
+  createEffect(() => {
+    if (show()) {
+      if (!current && !mounting) {
+        mounting = true;
+        let innerProps;
+        let innerChildren;
+        let currentEl;
+        const dispose = createRoot((_dispose) => {
+          innerProps = {};
+          innerChildren = {};
+          separatePropsAndChildren(props, innerProps, innerChildren);
+          resolveDynamicProps(innerProps, g, components, componentTypes, api, forCtx, ns, fullKey);
+          const componentState = syncComponentProps(type, name, innerProps, components, componentTypes);
+          bindInputStateProps(type, componentState, innerProps);
+          emit = (event, data) => {
+            if (event === "change")
+              applyComponentEventState(type, name, data, components, componentTypes);
+            const h = innerProps[`on${event}`];
+            if (typeof h === "function")
+              h(data);
+          };
+          currentEl = renderWithFallback(renderer, innerProps, name, {
+            g,
+            api,
+            dir: options.dir,
+            labels: options.labels,
+            document: container.ownerDocument || document,
+            forCtx,
+            children: innerChildren,
+            id: name || null,
+            emit,
+            renderTree: (layout, _container, childForCtx) => renderTree(layout, _container, g, components, componentTypes, childForCtx ?? forCtx, ns, api, options, false)
+          }, fullKey, ns);
+          return _dispose;
+        });
+        mounting = false;
+        if (currentEl) {
+          container.appendChild(currentEl);
+          applyEnterAnimation(currentEl, innerProps);
+          callHook(g, name, "onMount");
+          current = {
+            el: currentEl,
+            props: innerProps,
+            dispose,
+            disposed: false
+          };
+        } else {
+          dispose();
+        }
+      }
+    } else {
+      if (current) {
+        const instance = current;
+        current = null;
+        leavingInstances.add(instance);
+        applyLeaveAnimation(instance.el, instance.props, () => {
+          disposeInstance(instance);
+        });
+      }
+    }
+  });
+  onCleanup(() => {
+    if (current)
+      disposeInstance(current);
+    for (const instance of Array.from(leavingInstances))
+      disposeInstance(instance);
+  });
+}
+function renderAndMountSlot(item, index, keyVal, indexSignal, revisionSignal, renderer, type, name, props, container, g, components, componentTypes, api, forCtx, ns, fullKey, options) {
+  indexSignal[1](index);
+  const reactiveItem = asReactiveValue(item, g);
+  const innerForCtx = {
+    ...forCtx,
+    $item: reactiveItem,
+    $index: indexSignal[0],
+    $key: keyVal,
+    $revision: revisionSignal[0]
+  };
+  if (name) {
+    innerForCtx[name] = reactiveItem;
+  }
+  let innerProps;
+  let innerChildren;
+  let el;
+  let fEmit;
+  const dispose = createRoot((_dispose) => {
+    innerProps = {};
+    innerChildren = {};
+    separatePropsAndChildren(props, innerProps, innerChildren);
+    resolveDynamicProps(innerProps, g, components, componentTypes, api, innerForCtx, ns, fullKey);
+    const componentState = syncComponentProps(type, name, innerProps, components, componentTypes);
+    bindInputStateProps(type, componentState, innerProps);
+    fEmit = (event, data) => {
+      if (event === "change")
+        applyComponentEventState(type, name, data, components, componentTypes);
+      const h = innerProps[`on${event}`];
+      if (typeof h === "function")
+        h(data);
+    };
+    el = renderWithFallback(renderer, innerProps, name, {
+      g,
+      api,
+      dir: options.dir,
+      labels: options.labels,
+      document: container.ownerDocument || document,
+      forCtx: innerForCtx,
+      children: innerChildren,
+      id: name || null,
+      emit: fEmit,
+      renderTree: (layout, _container, childForCtx) => renderTree(layout, _container, g, components, componentTypes, childForCtx ?? innerForCtx, ns, api, options, false)
+    }, `${fullKey}[${index}]`, ns);
+    return _dispose;
+  });
+  return {
+    key: keyVal,
+    el,
+    forCtx: innerForCtx,
+    index,
+    item: reactiveItem,
+    props: innerProps,
+    children: innerChildren,
+    indexSignal,
+    revision: 0,
+    revisionSignal,
+    dispose
+  };
+}
+function renderForNode(fullKey, props, container, g, components, componentTypes, api, forCtx, ns, options) {
+  const [type, name] = fullKey.split(":");
+  const renderer = getRenderer(type);
+  if (!renderer)
+    return;
+  const forWrapper = (container.ownerDocument || document).createElement("div");
+  forWrapper.className = "slexkit-for-wrapper";
+  container.appendChild(forWrapper);
+  const evalCtx = buildComponentEvalContext(g, components, componentTypes, api, forCtx);
+  const items = createMemo(() => trackForCollection(evalRead(props.$for, evalCtx, ns, `${fullKey}:$for`)));
+  const $keyProp = props.$key;
+  const slotMap = new Map;
+  const leavingSlots = new Set;
+  const disposedSlots = new WeakSet;
+  const disposeSlot = (slot) => {
+    if (disposedSlots.has(slot))
+      return;
+    disposedSlots.add(slot);
+    leavingSlots.delete(slot);
+    callHook(g, name, "onUnmount");
+    disposeComponent(slot.el);
+    slot.el.remove();
+    if (slot.dispose)
+      slot.dispose();
+  };
+  createEffect(() => {
+    const arr = items();
+    if (!Array.isArray(arr)) {
+      if (slotMap.size > 0) {
+        for (const [, slot] of slotMap) {
+          disposeSlot(slot);
+        }
+        slotMap.clear();
+      }
+      return;
+    }
+    const newKeys = arr.map((item, i) => resolveKeyValue(item, i, $keyProp));
+    const newKeySet = new Set(newKeys);
+    const deletedSlots = [];
+    for (const [oldKey, slot] of slotMap) {
+      if (!newKeySet.has(oldKey)) {
+        deletedSlots.push(slot);
+        slotMap.delete(oldKey);
+      }
+    }
+    for (const slot of deletedSlots) {
+      container.appendChild(slot.el);
+      leavingSlots.add(slot);
+      applyLeaveAnimation(slot.el, slot.props, () => {
+        disposeSlot(slot);
+      });
+    }
+    arr.forEach((item, index) => {
+      item = asReactiveValue(item, g);
+      const keyVal = newKeys[index];
+      let slot = slotMap.get(keyVal);
+      if (slot) {
+        const indexChanged = slot.index !== index;
+        const itemChanged = slot.item !== item;
+        slot.forCtx.$item = item;
+        slot.forCtx.$key = keyVal;
+        if (name)
+          slot.forCtx[name] = item;
+        slot.index = index;
+        slot.item = item;
+        if (slot.revisionSignal) {
+          slot.revision = (slot.revision ?? 0) + 1;
+          slot.revisionSignal[1](slot.revision);
+        }
+        if (indexChanged || itemChanged) {
+          if (indexChanged && slot.indexSignal) {
+            slot.indexSignal[1](index);
+          }
+          callHook(g, name, "onUpdate");
+        }
+      } else {
+        const indexSignal = createSignal(index);
+        const revisionSignal = createSignal(0);
+        slot = renderAndMountSlot(item, index, keyVal, indexSignal, revisionSignal, renderer, type, name, props, container, g, components, componentTypes, api, forCtx, ns, fullKey, options);
+        if (slot.el) {
+          applyEnterAnimation(slot.el, slot.props);
+          callHook(g, name, "onMount");
+        }
+        slotMap.set(keyVal, slot);
+      }
+      const refChild = forWrapper.children[index];
+      if (slot.el && refChild !== slot.el) {
+        forWrapper.insertBefore(slot.el, refChild ?? null);
+      }
+    });
+    while (forWrapper.children.length > arr.length) {
+      forWrapper.lastChild.remove();
+    }
+  });
+  onCleanup(() => {
+    for (const slot of Array.from(slotMap.values()))
+      disposeSlot(slot);
+    slotMap.clear();
+    for (const slot of Array.from(leavingSlots))
+      disposeSlot(slot);
+    forWrapper.remove();
+  });
+}
+function renderNormalNode(fullKey, props, container, g, components, componentTypes, api, forCtx, ns, options) {
+  const [type, name] = fullKey.split(":");
+  const renderer = getRenderer(type);
+  if (!renderer)
+    return;
+  const nodeProps = {};
+  const nodeChildren = {};
+  separatePropsAndChildren(props, nodeProps, nodeChildren);
+  resolveDynamicProps(nodeProps, g, components, componentTypes, api, forCtx, ns, fullKey);
+  const componentState = syncComponentProps(type, name, nodeProps, components, componentTypes);
+  bindInputStateProps(type, componentState, nodeProps);
+  const nEmit = (event, data) => {
+    if (event === "change")
+      applyComponentEventState(type, name, data, components, componentTypes);
+    const h = nodeProps[`on${event}`];
+    if (typeof h === "function")
+      h(data);
+  };
+  const el = renderWithFallback(renderer, nodeProps, name, {
+    g,
+    api,
+    dir: options.dir,
+    labels: options.labels,
+    document: container.ownerDocument || document,
+    forCtx,
+    children: nodeChildren,
+    id: name || null,
+    emit: nEmit,
+    renderTree: (layout, _container, childForCtx) => renderTree(layout, _container, g, components, componentTypes, childForCtx ?? forCtx, ns, api, options, false)
+  }, fullKey, ns);
+  if (el) {
+    container.appendChild(el);
+    applyEnterAnimation(el, nodeProps);
+    callHook(g, name, "onMount");
+    onCleanup(() => callHook(g, name, "onUnmount"));
+    onCleanup(() => disposeComponent(el));
+  }
+}
+function renderNode(fullKey, props, container, g, components, componentTypes, api, forCtx, ns, options) {
+  if (!fullKey || !fullKey.includes(":"))
+    return;
+  if (props.$if) {
+    renderIfNode(fullKey, props, container, g, components, componentTypes, api, forCtx, ns, options);
+  } else if (props.$for) {
+    renderForNode(fullKey, props, container, g, components, componentTypes, api, forCtx, ns, options);
+  } else {
+    renderNormalNode(fullKey, props, container, g, components, componentTypes, api, forCtx, ns, options);
+  }
+}
+function renderTree(layout, container, g, components, componentTypes, forCtx, ns = "?", api, options = defaultRenderOptions, prepare = true) {
+  if (!layout || typeof layout !== "object")
+    return;
+  if (prepare)
+    prepareComponentStates(layout, components, componentTypes, ns);
+  for (const [key, val] of Object.entries(layout)) {
+    if (!key.includes(":"))
+      continue;
+    if (typeof val === "object" && val !== null) {
+      renderNode(key, val, container, g, components, componentTypes, api, forCtx, ns, options);
+    }
+  }
+}
+
+// src/engine/diagnostics.ts
+class SlexKitSyntaxError extends SyntaxError {
+  diagnostic;
+  constructor(diagnostic) {
+    super(formatSlexKitDiagnostic(diagnostic));
+    this.name = "SlexKitSyntaxError";
+    this.diagnostic = diagnostic;
+  }
+}
+function excerpt(source, line, column) {
+  const lines = source.split(`
+`);
+  const start = Math.max(1, line - 2);
+  const end = Math.min(lines.length, line + 2);
+  const width = String(end).length;
+  const rows = [];
+  for (let current = start;current <= end; current += 1) {
+    const marker = current === line ? ">" : " ";
+    rows.push(`${marker} ${String(current).padStart(width, " ")} | ${lines[current - 1] ?? ""}`);
+    if (current === line) {
+      rows.push(`  ${" ".repeat(width)} | ${" ".repeat(Math.max(0, column - 1))}^`);
+    }
+  }
+  return rows.join(`
+`);
+}
+function lineColumnAt(source, index) {
+  const prefix = source.slice(0, Math.max(0, index));
+  const lines = prefix.split(`
+`);
+  return {
+    line: lines.length,
+    column: lines[lines.length - 1].length + 1
+  };
+}
+function stackLine(error) {
+  if (!(error instanceof Error) || !error.stack)
+    return null;
+  const match = error.stack.match(/<parse>\s+\(:(\d+)\)/);
+  if (!match)
+    return null;
+  const parsed = Number(match[1]);
+  return Number.isFinite(parsed) ? Math.max(1, parsed - 2) : null;
+}
+function scanSource(source) {
+  const chars = [];
+  let quote = "";
+  let escaped = false;
+  let line = 1;
+  let column = 0;
+  for (let index = 0;index < source.length; index += 1) {
+    const char = source[index];
+    const next = source[index + 1];
+    column += 1;
+    if (char === `
+`) {
+      line += 1;
+      column = 0;
+      if (quote === "//")
+        quote = "";
+      continue;
+    }
+    if (quote) {
+      if (quote === "/*" && char === "*" && next === "/") {
+        quote = "";
+        index += 1;
+        column += 1;
+      } else if (quote !== "/*" && quote !== "//" && !escaped && char === quote) {
+        quote = "";
+      }
+      escaped = !escaped && quote !== "/*" && quote !== "//" && char === "\\";
+      if (char !== "\\")
+        escaped = false;
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      quote = "//";
+      index += 1;
+      column += 1;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      quote = "/*";
+      index += 1;
+      column += 1;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      escaped = false;
+      continue;
+    }
+    chars.push({ char, index, line, column });
+  }
+  return chars;
+}
+function tokenDiagnostic(source, message) {
+  const chars = scanSource(source);
+  const unexpectedString = message.match(/Unexpected string(?: literal)?(?: "([^"]+)")?/);
+  if (unexpectedString) {
+    const literal = unexpectedString[1];
+    if (literal) {
+      const quoted = [`"${literal}"`, `'${literal}'`, `\`${literal}\``];
+      const index = quoted.map((candidate) => source.indexOf(candidate)).filter((candidate) => candidate >= 0).sort((a, b) => a - b)[0];
+      if (index !== undefined)
+        return lineColumnAt(source, index);
+    }
+    const suspiciousString = source.match(/[}\])"']\s*(['"`])/);
+    if (suspiciousString?.index !== undefined) {
+      const quoteIndex = source.indexOf(suspiciousString[1], suspiciousString.index + 1);
+      if (quoteIndex >= 0)
+        return lineColumnAt(source, quoteIndex);
+    }
+  }
+  if (message.includes("Unexpected token ':'")) {
+    const doubleColon = chars.find((item, index) => item.char === ":" && chars[index - 1]?.char === ":");
+    if (doubleColon)
+      return doubleColon;
+    const suspiciousColon = chars.find((item, index) => {
+      if (item.char !== ":")
+        return false;
+      const prev = chars[index - 1]?.char;
+      return prev === '"' || prev === "'" || prev === "}" || prev === "]" || prev === ")";
+    });
+    if (suspiciousColon)
+      return suspiciousColon;
+  }
+  return null;
+}
+function delimiterDiagnostic(source) {
+  const stack = [];
+  const pairs = { "}": "{", "]": "[", ")": "(" };
+  for (const item of scanSource(source)) {
+    if (item.char === "{" || item.char === "[" || item.char === "(") {
+      stack.push(item);
+      continue;
+    }
+    if (item.char === "}" || item.char === "]" || item.char === ")") {
+      const expected = pairs[item.char];
+      const opener2 = stack.pop();
+      if (!opener2 || opener2.char !== expected) {
+        return {
+          line: item.line,
+          column: item.column,
+          detail: `Unexpected closing delimiter ${item.char}.`
+        };
+      }
+    }
+  }
+  const opener = stack.at(-1);
+  if (!opener)
+    return null;
+  const end = lineColumnAt(source, source.length);
+  return {
+    line: end.line,
+    column: end.column,
+    detail: `Expected closing delimiter for ${opener.char} opened at line ${opener.line}, column ${opener.column}.`
+  };
+}
+function locateSyntaxError(source, error) {
+  const rawMessage = error instanceof Error ? error.message : String(error);
+  const delimiter = delimiterDiagnostic(source);
+  const token = tokenDiagnostic(source, rawMessage);
+  const stack = stackLine(error);
+  const position = token ?? (delimiter && rawMessage.includes("Expected") ? delimiter : null) ?? (stack ? { line: stack, column: 1 } : null) ?? delimiter ?? { line: 1, column: 1 };
+  const detail = token ? "The parser failed at this token." : delimiter?.detail;
+  return {
+    message: rawMessage,
+    line: position.line,
+    column: position.column,
+    detail,
+    excerpt: excerpt(source, position.line, position.column)
+  };
+}
+function readStringLiteral(source, start) {
+  const quote = source[start];
+  if (quote !== '"' && quote !== "'" && quote !== "`")
+    return null;
+  let escaped = false;
+  for (let index = start + 1;index < source.length; index += 1) {
+    const char = source[index];
+    if (!escaped && char === quote) {
+      return { end: index + 1, value: source.slice(start, index + 1) };
+    }
+    escaped = !escaped && char === "\\";
+    if (char !== "\\")
+      escaped = false;
+  }
+  return null;
+}
+function skipWhitespace(source, index) {
+  let cursor = index;
+  while (cursor < source.length && /\s/.test(source[cursor]))
+    cursor += 1;
+  return cursor;
+}
+function findExpressionEnd(source, start) {
+  const stack = [];
+  let quote = "";
+  let escaped = false;
+  for (let index = start;index < source.length; index += 1) {
+    const char = source[index];
+    const next = source[index + 1];
+    if (quote) {
+      if (quote === "//" && char === `
+`) {
+        quote = "";
+      } else if (quote === "/*" && char === "*" && next === "/") {
+        quote = "";
+        index += 1;
+      } else if (quote !== "//" && quote !== "/*" && !escaped && char === quote) {
+        quote = "";
+      }
+      escaped = !escaped && quote !== "//" && quote !== "/*" && char === "\\";
+      if (char !== "\\")
+        escaped = false;
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      quote = "//";
+      index += 1;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      quote = "/*";
+      index += 1;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      escaped = false;
+      continue;
+    }
+    if (char === "{" || char === "[" || char === "(") {
+      stack.push(char);
+      continue;
+    }
+    if (char === "}" || char === "]" || char === ")") {
+      if (stack.length === 0)
+        return index;
+      stack.pop();
+      continue;
+    }
+    if (char === "," && stack.length === 0)
+      return index;
+  }
+  return source.length;
+}
+function isSingleStringLiteral(source) {
+  const start = skipWhitespace(source, 0);
+  const literal = readStringLiteral(source, start);
+  return Boolean(literal && skipWhitespace(source, literal.end) === source.length);
+}
+function transformDynamicPropExpressions(source) {
+  const edits = [];
+  const keyPattern = /(^|[,{]\s*)(\$[A-Za-z_$][\w$]*)\s*:/g;
+  let match;
+  while (match = keyPattern.exec(source)) {
+    const colon = source.indexOf(":", match.index + match[1].length);
+    const valueStart = skipWhitespace(source, colon + 1);
+    const valueEnd = findExpressionEnd(source, valueStart);
+    const rawValue = source.slice(valueStart, valueEnd);
+    if (!rawValue.trim() || isSingleStringLiteral(rawValue))
+      continue;
+    edits.push({
+      start: valueStart,
+      end: valueEnd,
+      value: JSON.stringify(rawValue.trim())
+    });
+  }
+  if (edits.length === 0)
+    return source;
+  let transformed = source;
+  for (let index = edits.length - 1;index >= 0; index -= 1) {
+    const edit = edits[index];
+    transformed = `${transformed.slice(0, edit.start)}${edit.value}${transformed.slice(edit.end)}`;
+  }
+  return transformed;
+}
+function formatSlexKitDiagnostic(diagnostic) {
+  const detail = diagnostic.detail ? `
+${diagnostic.detail}` : "";
+  return `${diagnostic.message} at line ${diagnostic.line}, column ${diagnostic.column}.${detail}
+${diagnostic.excerpt}`;
+}
+function diagnoseSlexKitSource(source, error) {
+  return locateSyntaxError(source, error);
+}
+function parseSlexSource(source) {
+  try {
+    const parseSource = transformDynamicPropExpressions(source);
+    return {
+      ok: true,
+      value: new Function(`"use strict";
+return (
+${parseSource}
+);`)()
+    };
+  } catch (error) {
+    const diagnostic = diagnoseSlexKitSource(source, error);
+    return {
+      ok: false,
+      diagnostic,
+      error: new SlexKitSyntaxError(diagnostic)
+    };
+  }
+}
+var parseSlexKitDsl = parseSlexSource;
+
+// src/version.ts
+var SLEXKIT_VERSION = "0.2.0";
+var SLEX_PROTOCOL_VERSION = "0.1";
+var SLEXKIT_COMPONENTS_VERSION = SLEXKIT_VERSION;
+function getSlexKitInfo() {
+  return {
+    version: SLEXKIT_VERSION,
+    protocolVersion: SLEX_PROTOCOL_VERSION,
+    componentsVersion: SLEXKIT_COMPONENTS_VERSION
+  };
+}
+
+// src/engine/secure-runtime.ts
+class SlexKitRuntimeError extends Error {
+  kind;
+  code;
+  elapsedMs;
+  constructor(kind, code, message, elapsedMs) {
+    super(message);
+    this.name = "SlexKitRuntimeError";
+    this.kind = kind;
+    this.code = code;
+    this.elapsedMs = elapsedMs;
+  }
+}
+function runtimeNow(adapter) {
+  if (adapter?.now)
+    return adapter.now();
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return performance.now();
+  }
+  return Date.now();
+}
+function currentOrigin() {
+  if (typeof location !== "undefined" && location.origin)
+    return location.origin;
+  if (typeof window !== "undefined" && window.location?.origin)
+    return window.location.origin;
+  return "http://localhost";
+}
+function resolveUrl(url) {
+  try {
+    return new URL(url, currentOrigin());
+  } catch {
+    throw new SlexKitRuntimeError("policy", "invalid_url", "Invalid request URL.");
+  }
+}
+function originAllowed(origin, patterns) {
+  let parsedOrigin;
+  try {
+    parsedOrigin = new URL(origin);
+  } catch {
+    return false;
+  }
+  for (const pattern of patterns) {
+    const normalized = pattern.trim();
+    if (normalized === "*" || normalized === origin)
+      return true;
+    if (normalized.endsWith("://*")) {
+      const protocol = normalized.slice(0, -4);
+      if (parsedOrigin.protocol === `${protocol}:`)
+        return true;
+    }
+    const wildcard = normalized.match(/^([a-z][a-z0-9+.-]*):\/\/\*\.(.+)$/i);
+    if (wildcard && parsedOrigin.protocol === `${wildcard[1]}:`) {
+      const suffix = wildcard[2].toLowerCase();
+      const host = parsedOrigin.hostname.toLowerCase();
+      if (host.endsWith(`.${suffix}`))
+        return true;
+    }
+  }
+  return false;
+}
+function needsJsonBody(method, body) {
+  if (method !== "POST" || body === undefined)
+    return false;
+  return !(typeof body === "string" || body instanceof ArrayBuffer || ArrayBuffer.isView(body));
+}
+function bodySize(body) {
+  if (body === undefined || body === null)
+    return 0;
+  if (typeof body === "string")
+    return body.length;
+  if (body instanceof ArrayBuffer)
+    return body.byteLength;
+  if (ArrayBuffer.isView(body))
+    return body.byteLength;
+  return JSON.stringify(body).length;
+}
+var DEFAULT_ALLOWED_HEADERS = ["accept", "content-type"];
+var BLOCKED_HEADERS = [
+  "authorization",
+  "cookie",
+  "proxy-authorization",
+  "sec-fetch-dest",
+  "sec-fetch-mode",
+  "sec-fetch-site",
+  "sec-fetch-user",
+  "set-cookie"
+];
+function normalizeHeaderName(name) {
+  return name.trim().toLowerCase();
+}
+function assertHeaders(headers, allowHeaders) {
+  if (!headers)
+    return;
+  const allowed = new Set((allowHeaders ?? DEFAULT_ALLOWED_HEADERS).map(normalizeHeaderName));
+  for (const [name, value] of Object.entries(headers)) {
+    const normalized = normalizeHeaderName(name);
+    if (!normalized || typeof value !== "string") {
+      throw new SlexKitRuntimeError("policy", "header_blocked", "Request header is not allowed.");
+    }
+    if (BLOCKED_HEADERS.includes(normalized) || !allowed.has(normalized)) {
+      throw new SlexKitRuntimeError("policy", "header_blocked", `Request header ${name} is not allowed.`);
+    }
+  }
+}
+function responseSize(result) {
+  if (typeof result.text === "string")
+    return result.text.length;
+  if (result.data !== undefined) {
+    try {
+      return JSON.stringify(result.data).length;
+    } catch {
+      return 0;
+    }
+  }
+  return 0;
+}
+function contentTypeAllowed(contentType, patterns) {
+  const normalized = contentType.split(";")[0].trim().toLowerCase();
+  if (!normalized)
+    return false;
+  return patterns.some((pattern) => {
+    const allowed = pattern.trim().toLowerCase();
+    if (allowed === "*" || allowed === normalized)
+      return true;
+    if (allowed.endsWith("/*")) {
+      return normalized.startsWith(`${allowed.slice(0, -1)}`);
+    }
+    return false;
+  });
+}
+function responseHeader(headers, name) {
+  const target = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === target)
+      return value;
+  }
+  return;
+}
+function assertNetworkResult(result, policy) {
+  if (!policy)
+    return;
+  if (policy.maxResponseBytes !== undefined && responseSize(result) > policy.maxResponseBytes) {
+    throw new SlexKitRuntimeError("policy", "response_too_large", "Response body exceeds the runtime policy limit.", result.elapsedMs);
+  }
+  if (policy.allowContentTypes?.length) {
+    const contentType = responseHeader(result.headers, "content-type");
+    if (!contentType || !contentTypeAllowed(contentType, policy.allowContentTypes)) {
+      throw new SlexKitRuntimeError("policy", "content_type_blocked", `Response content-type ${contentType || "unknown"} is not allowed.`, result.elapsedMs);
+    }
+  }
+}
+function canvasPolicy(policy) {
+  const canvas = policy.canvas;
+  if (!canvas?.enabled) {
+    throw new SlexKitRuntimeError("policy", "canvas_disabled", "Canvas access is disabled.");
+  }
+  return canvas;
+}
+function assertCanvasDimensions(policy, width, height) {
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+    throw new SlexKitRuntimeError("policy", "canvas_size_invalid", "Canvas size must be positive finite numbers.");
+  }
+  const pixels = Math.ceil(width) * Math.ceil(height);
+  if (policy.maxPixels !== undefined && pixels > policy.maxPixels) {
+    throw new SlexKitRuntimeError("policy", "canvas_too_large", "Canvas size exceeds the runtime policy limit.");
+  }
+}
+function assertCanvasContext(policy, contextId) {
+  if (policy.allowedContexts?.length && !policy.allowedContexts.includes(contextId)) {
+    throw new SlexKitRuntimeError("policy", "canvas_context_blocked", `Canvas context ${contextId} is not allowed.`);
+  }
+}
+function emitNetworkLog(adapter, event) {
+  try {
+    adapter?.onNetworkLog?.(event);
+  } catch {}
+}
+function emitRuntimeError(adapter, event) {
+  try {
+    adapter?.onRuntimeError?.(event);
+  } catch {}
+}
+function timerHost(adapter) {
+  const globalTimer = globalThis;
+  return {
+    setTimeout: adapter?.setTimeout ?? ((fn, ms) => Number(globalTimer.setTimeout(fn, ms))),
+    clearTimeout: adapter?.clearTimeout ?? ((id) => globalTimer.clearTimeout(id)),
+    setInterval: adapter?.setInterval ?? ((fn, ms) => Number(globalTimer.setInterval(fn, ms))),
+    clearInterval: adapter?.clearInterval ?? ((id) => globalTimer.clearInterval(id))
+  };
+}
+function rafHost(adapter) {
+  const globalRaf = globalThis;
+  return {
+    requestAnimationFrame: adapter?.requestAnimationFrame ?? ((fn) => {
+      if (typeof globalRaf.requestAnimationFrame === "function") {
+        return Number(globalRaf.requestAnimationFrame(fn));
+      }
+      return Number(globalThis.setTimeout(() => fn(runtimeNow(adapter)), 16));
+    }),
+    cancelAnimationFrame: adapter?.cancelAnimationFrame ?? ((id) => {
+      if (typeof globalRaf.cancelAnimationFrame === "function") {
+        globalRaf.cancelAnimationFrame(id);
+      } else {
+        globalThis.clearTimeout(id);
+      }
+    })
+  };
+}
+async function readResponseText(response, maxResponseBytes) {
+  if (maxResponseBytes === undefined || !response.body?.getReader) {
+    const text2 = await response.text();
+    if (maxResponseBytes !== undefined && text2.length > maxResponseBytes) {
+      throw new SlexKitRuntimeError("policy", "response_too_large", "Response body exceeds the runtime policy limit.");
+    }
+    return text2;
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  let size = 0;
+  let text = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    size += value.byteLength;
+    if (size > maxResponseBytes) {
+      await reader.cancel();
+      throw new SlexKitRuntimeError("policy", "response_too_large", "Response body exceeds the runtime policy limit.");
+    }
+    text += decoder.decode(value, { stream: true });
+  }
+  text += decoder.decode();
+  return text;
+}
+async function defaultFetch(request, adapter, options = {}) {
+  if (adapter?.fetch)
+    return adapter.fetch(request);
+  if (typeof fetch !== "function") {
+    throw new SlexKitRuntimeError("network", "fetch_unavailable", "Host fetch is unavailable.");
+  }
+  const start = runtimeNow(adapter);
+  const controller = typeof AbortController !== "undefined" ? new AbortController : undefined;
+  const releaseController = controller ? options.onController?.(controller) : undefined;
+  const timeout = controller ? globalThis.setTimeout(() => controller.abort(), request.timeoutMs) : undefined;
+  try {
+    const init = {
+      method: request.method,
+      headers: request.headers,
+      credentials: request.credentials,
+      signal: controller?.signal
+    };
+    if (request.method === "POST" && request.body !== undefined) {
+      if (typeof request.body === "string" || request.body instanceof ArrayBuffer || ArrayBuffer.isView(request.body)) {
+        init.body = request.body;
+      } else {
+        init.body = JSON.stringify(request.body);
+        init.headers = request.headers;
+      }
+    }
+    const response = await fetch(request.url, init);
+    const text = await readResponseText(response, options.maxResponseBytes);
+    let data = undefined;
+    try {
+      data = text ? JSON.parse(text) : undefined;
+    } catch {
+      data = undefined;
+    }
+    const headers = {};
+    response.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    return {
+      ok: response.ok,
+      status: response.status,
+      statusText: response.statusText,
+      url: response.url,
+      headers,
+      text,
+      data,
+      elapsedMs: runtimeNow(adapter) - start
+    };
+  } catch (error) {
+    const elapsedMs = runtimeNow(adapter) - start;
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new SlexKitRuntimeError("timeout", "timeout", "Request timed out.", elapsedMs);
+    }
+    throw new SlexKitRuntimeError("network", "network_error", errorMessage(error), elapsedMs);
+  } finally {
+    if (timeout !== undefined)
+      globalThis.clearTimeout(timeout);
+    releaseController?.();
+  }
+}
+function errorMessage(error) {
+  if (error instanceof Error)
+    return error.message;
+  if (error && typeof error === "object" && "message" in error) {
+    return String(error.message);
+  }
+  return String(error ?? "Unknown error.");
+}
+function serializeRuntimeError(error) {
+  if (error instanceof SlexKitRuntimeError) {
+    return {
+      name: error.name,
+      message: error.message,
+      kind: error.kind,
+      code: error.code,
+      elapsedMs: error.elapsedMs
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message
+    };
+  }
+  return {
+    name: "Error",
+    message: errorMessage(error)
+  };
+}
+function deserializeRuntimeError(error) {
+  if (error.name === "SlexKitRuntimeError" && error.kind && error.code) {
+    return new SlexKitRuntimeError(error.kind, error.code, error.message, error.elapsedMs);
+  }
+  const next = new Error(error.message);
+  next.name = error.name || "Error";
+  return next;
+}
+function createSecureRuntime(policy, hostAdapter) {
+  const disposers = new Set;
+  const timeoutIds = new Set;
+  const intervalIds = new Set;
+  const rafIds = new Set;
+  const abortControllers = new Set;
+  const ownedCanvases = new Set;
+  const countedCanvases = new Set;
+  let disposed = false;
+  let nextSyntheticId = 1;
+  const syntheticTimers = new Map;
+  const timers = timerHost(hostAdapter);
+  const raf = rafHost(hostAdapter);
+  function assertNotDisposed() {
+    if (disposed) {
+      throw new SlexKitRuntimeError("policy", "runtime_disposed", "Runtime has been disposed.");
+    }
+  }
+  function assertNetwork(method, url, options = {}) {
+    const network = policy.network;
+    if (!network?.enabled) {
+      throw new SlexKitRuntimeError("policy", "network_disabled", "Network access is disabled.");
+    }
+    if (!network.methods.includes(method)) {
+      throw new SlexKitRuntimeError("policy", "method_blocked", `Network method ${method} is not allowed.`);
+    }
+    const parsed = resolveUrl(url);
+    if (!originAllowed(parsed.origin, network.allowOrigins)) {
+      throw new SlexKitRuntimeError("policy", "origin_blocked", `Network origin ${parsed.origin} is not allowed.`);
+    }
+    if (method === "POST" && bodySize(options.body) > network.maxBodyBytes) {
+      throw new SlexKitRuntimeError("policy", "body_too_large", "Request body exceeds the runtime policy limit.");
+    }
+    const headers = needsJsonBody(method, options.body) ? { "content-type": "application/json", ...options.headers } : options.headers;
+    assertHeaders(headers, network.allowHeaders);
+    const timeoutMs = Math.min(options.timeoutMs ?? network.timeoutMs, network.timeoutMs);
+    const credentials = options.credentials ?? network.credentials;
+    if (credentials !== network.credentials) {
+      throw new SlexKitRuntimeError("policy", "credentials_blocked", "Request credentials mode is not allowed.");
+    }
+    return {
+      method,
+      url: parsed.href,
+      headers,
+      body: options.body,
+      credentials,
+      timeoutMs
+    };
+  }
+  function assertTimer(ms) {
+    const timer = policy.timer;
+    if (!timer?.enabled) {
+      throw new SlexKitRuntimeError("policy", "timer_disabled", "Timer access is disabled.");
+    }
+    if (!Number.isFinite(ms) || ms < timer.minIntervalMs) {
+      throw new SlexKitRuntimeError("policy", "timer_interval_blocked", "Timer interval is below policy limit.");
+    }
+    if (timeoutIds.size + intervalIds.size >= timer.maxTimers) {
+      throw new SlexKitRuntimeError("policy", "timer_limit", "Timer limit exceeded.");
+    }
+  }
+  function normalizeTimerId(raw) {
+    if (Number.isFinite(raw) && raw > 0)
+      return raw;
+    const synthetic = nextSyntheticId++;
+    syntheticTimers.set(synthetic, raw);
+    return synthetic;
+  }
+  function assertCanvas(width, height) {
+    assertNotDisposed();
+    const canvas = canvasPolicy(policy);
+    assertCanvasDimensions(canvas, width, height);
+    if (canvas.maxCanvases !== undefined && countedCanvases.size >= canvas.maxCanvases) {
+      throw new SlexKitRuntimeError("policy", "canvas_limit", "Canvas limit exceeded.");
+    }
+    return canvas;
+  }
+  function countCanvas(canvas, policy2) {
+    if (countedCanvases.has(canvas))
+      return;
+    if (policy2.maxCanvases !== undefined && countedCanvases.size >= policy2.maxCanvases) {
+      throw new SlexKitRuntimeError("policy", "canvas_limit", "Canvas limit exceeded.");
+    }
+    countedCanvases.add(canvas);
+  }
+  function reportCallbackError(phase, error) {
+    emitRuntimeError(hostAdapter, {
+      phase,
+      error: serializeRuntimeError(error)
+    });
+  }
+  const api = {
+    now: () => runtimeNow(hostAdapter),
+    get: (url, options = {}) => api.fetch(url, { ...options, method: "GET" }),
+    post: (url, body, options = {}) => api.fetch(url, { ...options, method: "POST", body }),
+    fetch: async (url, options = {}) => {
+      assertNotDisposed();
+      const method = options.method ?? "GET";
+      const request = assertNetwork(method, url, options);
+      const started = runtimeNow(hostAdapter);
+      emitNetworkLog(hostAdapter, { phase: "request", request });
+      try {
+        const result = await defaultFetch(request, hostAdapter, {
+          maxResponseBytes: policy.network?.maxResponseBytes,
+          onController(controller) {
+            abortControllers.add(controller);
+            return () => abortControllers.delete(controller);
+          }
+        });
+        assertNetworkResult(result, policy.network);
+        emitNetworkLog(hostAdapter, {
+          phase: "response",
+          request,
+          result,
+          elapsedMs: runtimeNow(hostAdapter) - started
+        });
+        return result;
+      } catch (error) {
+        const serialized = serializeRuntimeError(error);
+        emitNetworkLog(hostAdapter, {
+          phase: "error",
+          request,
+          error: serialized,
+          elapsedMs: runtimeNow(hostAdapter) - started
+        });
+        throw error;
+      }
+    },
+    setTimeout: (fn, ms) => {
+      assertNotDisposed();
+      assertTimer(ms);
+      let id = 0;
+      const raw = timers.setTimeout(() => {
+        timeoutIds.delete(id);
+        syntheticTimers.delete(id);
+        try {
+          fn();
+        } catch (error) {
+          reportCallbackError("timer", error);
+          throw error;
+        }
+      }, ms);
+      id = normalizeTimerId(raw);
+      timeoutIds.add(id);
+      return id;
+    },
+    clearTimeout: (id) => {
+      const raw = syntheticTimers.get(id) ?? id;
+      timers.clearTimeout(raw);
+      timeoutIds.delete(id);
+      syntheticTimers.delete(id);
+    },
+    setInterval: (fn, ms) => {
+      assertNotDisposed();
+      assertTimer(ms);
+      const id = normalizeTimerId(timers.setInterval(() => {
+        try {
+          fn();
+        } catch (error) {
+          reportCallbackError("interval", error);
+          throw error;
+        }
+      }, ms));
+      intervalIds.add(id);
+      return id;
+    },
+    clearInterval: (id) => {
+      const raw = syntheticTimers.get(id) ?? id;
+      timers.clearInterval(raw);
+      intervalIds.delete(id);
+      syntheticTimers.delete(id);
+    },
+    raf: (fn) => {
+      assertNotDisposed();
+      if (!policy.animation?.enabled) {
+        throw new SlexKitRuntimeError("policy", "animation_disabled", "Animation access is disabled.");
+      }
+      const id = raf.requestAnimationFrame((time) => {
+        rafIds.delete(id);
+        try {
+          fn(time);
+        } catch (error) {
+          reportCallbackError("raf", error);
+          throw error;
+        }
+      });
+      rafIds.add(id);
+      return id;
+    },
+    cancelRaf: (id) => {
+      raf.cancelAnimationFrame(id);
+      rafIds.delete(id);
+    },
+    createCanvas: (width, height) => {
+      assertCanvas(width, height);
+      if (typeof document === "undefined" || typeof document.createElement !== "function") {
+        throw new SlexKitRuntimeError("policy", "canvas_unavailable", "Canvas is unavailable in this runtime.");
+      }
+      const canvas = document.createElement("canvas");
+      canvas.width = Math.ceil(width);
+      canvas.height = Math.ceil(height);
+      ownedCanvases.add(canvas);
+      countedCanvases.add(canvas);
+      return canvas;
+    },
+    getCanvasContext: (canvas, contextId = "2d", options) => {
+      assertNotDisposed();
+      const canvasAccess = canvasPolicy(policy);
+      assertCanvasDimensions(canvasAccess, canvas.width, canvas.height);
+      assertCanvasContext(canvasAccess, contextId);
+      countCanvas(canvas, canvasAccess);
+      const context = canvas.getContext(contextId, options);
+      if (!context) {
+        throw new SlexKitRuntimeError("policy", "canvas_context_unavailable", `Canvas context ${contextId} is unavailable.`);
+      }
+      return context;
+    },
+    onDispose: (fn) => {
+      disposers.add(fn);
+    },
+    isTimeoutError: (error) => error instanceof SlexKitRuntimeError && error.kind === "timeout",
+    isNetworkError: (error) => error instanceof SlexKitRuntimeError && error.kind === "network",
+    isPolicyError: (error) => error instanceof SlexKitRuntimeError && error.kind === "policy",
+    errorMessage
+  };
+  return {
+    api,
+    dispose: () => {
+      if (disposed)
+        return;
+      disposed = true;
+      for (const id of Array.from(timeoutIds))
+        api.clearTimeout(id);
+      for (const id of Array.from(intervalIds))
+        api.clearInterval(id);
+      for (const id of Array.from(rafIds))
+        api.cancelRaf(id);
+      for (const controller of Array.from(abortControllers))
+        controller.abort();
+      abortControllers.clear();
+      for (const canvas of Array.from(ownedCanvases)) {
+        if (canvas.isConnected)
+          canvas.remove();
+      }
+      ownedCanvases.clear();
+      countedCanvases.clear();
+      for (const disposer of Array.from(disposers)) {
+        try {
+          disposer();
+        } catch (error) {
+          reportCallbackError("dispose", error);
+        }
+      }
+      disposers.clear();
+    }
+  };
+}
+// src/engine/markdown-runtime.ts
+var DEFAULT_POLICY = {};
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isRenderableSource(value) {
+  if (!isRecord(value))
+    return false;
+  if ("layout" in value)
+    return isRecord(value.layout) && Object.keys(value.layout).length > 0;
+  if ("namespace" in value || "g" in value)
+    return false;
+  return Object.keys(value).some((key) => key.includes(":"));
+}
+function bareLayoutFromSource(value) {
+  const { slex: _slex, namespace: _namespace, g: _g, layout: _layout, ...layout } = value;
+  return layout;
+}
+function isStateOnlySource(value) {
+  return isRecord(value) && !isRenderableSource(value) && (("slex" in value) || ("namespace" in value) || ("g" in value));
+}
+function isSlexExpressionEnvelope(value) {
+  return isRecord(value) && (("slex" in value) || ("namespace" in value) || ("g" in value) || ("layout" in value));
+}
+function parseTrustedSource(source) {
+  if (typeof source !== "string")
+    return source;
+  const parsed = parseSlexSource(source);
+  return parsed.ok ? parsed.value : source;
+}
+function scopedTrustedSource(source, artifactId) {
+  if (!artifactId || !isSlexExpressionEnvelope(source)) {
+    return source;
+  }
+  if (!("layout" in source) && isRenderableSource(source)) {
+    return {
+      slex: typeof source.slex === "string" ? source.slex : undefined,
+      namespace: `${artifactId}::${String(source.namespace || "default")}`,
+      g: isRecord(source.g) ? source.g : {},
+      layout: bareLayoutFromSource(source)
+    };
+  }
+  return {
+    ...source,
+    namespace: `${artifactId}::${String(source.namespace || "default")}`
+  };
+}
+function namespaceFromSource(source) {
+  if (!isSlexExpressionEnvelope(source))
+    return;
+  return String(source.namespace || "default");
+}
+function compareDocumentOrder(a, b) {
+  if (a === b)
+    return 0;
+  const position = a.compareDocumentPosition(b);
+  if (position & Node.DOCUMENT_POSITION_FOLLOWING)
+    return -1;
+  if (position & Node.DOCUMENT_POSITION_PRECEDING)
+    return 1;
+  return 0;
+}
+function createSlexKitMarkdownRuntimeHost(initialOptions = {}) {
+  let options = {
+    mode: "trusted",
+    secureFrame: true,
+    policy: DEFAULT_POLICY,
+    ...initialOptions
+  };
+  const cleanups = new Map;
+  const artifactContainers = new Map;
+  const artifactSources = new Map;
+  const secureArtifactAnchors = new Map;
+  const secureArtifactCleanups = new Map;
+  const trustedArtifactNamespaces = new Map;
+  function rememberTrustedArtifactNamespace(artifactId, source) {
+    if (!artifactId)
+      return;
+    const namespace = namespaceFromSource(source);
+    if (!namespace)
+      return;
+    let namespaces = trustedArtifactNamespaces.get(artifactId);
+    if (!namespaces) {
+      namespaces = new Set;
+      trustedArtifactNamespaces.set(artifactId, namespaces);
+    }
+    namespaces.add(`${artifactId}::${namespace}`);
+  }
+  function disposeTrustedArtifactNamespaces(artifactId) {
+    const namespaces = trustedArtifactNamespaces.get(artifactId);
+    if (!namespaces)
+      return;
+    for (const namespace of namespaces)
+      disposeNamespace(namespace);
+    trustedArtifactNamespaces.delete(artifactId);
+  }
+  function composeSecureArtifactSource(artifactId) {
+    const sources = artifactSources.get(artifactId);
+    if (!sources)
+      return "";
+    const orderedSources = Array.from(sources.entries()).sort(([a], [b]) => compareDocumentOrder(a, b)).map(([, source]) => source);
+    const serializedSources = JSON.stringify(orderedSources.map((source) => ({
+      kind: typeof source === "string" ? "script" : "json",
+      source: encodeURIComponent(typeof source === "string" ? source : JSON.stringify(source))
+    })));
+    const artifactPrefix = JSON.stringify(`${artifactId}::`);
+    return `(() => {
+      const __sources = ${serializedSources}.map((entry) => ({
+        kind: entry.kind,
+        source: decodeURIComponent(entry.source),
+      }));
+      const __isRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+      const __merge = (target, source) => {
+        if (!__isRecord(source)) return target;
+        for (const [key, value] of Object.entries(source)) {
+          if (__isRecord(value) && __isRecord(target[key])) __merge(target[key], value);
+          else target[key] = value;
+        }
+        return target;
+      };
+      const __isRenderableTree = (value) => __isRecord(value) && Object.keys(value).some((key) => key.includes(":"));
+      const __artifactPrefix = ${artifactPrefix};
+      const __target = { slex: "0.1", namespace: __artifactPrefix + "default", g: {}, layout: {} };
+      const __layouts = [];
+      for (const __entry of __sources) {
+        const __script = __entry.kind === "json" ? JSON.parse(__entry.source) : (0, eval)(__entry.source);
+        if (!__isRecord(__script)) continue;
+        if ("slex" in __script) __target.slex = String(__script.slex || "0.1");
+        if ("namespace" in __script) __target.namespace = __artifactPrefix + String(__script.namespace || "default");
+        if (__isRecord(__script.g)) __merge(__target.g, __script.g);
+        if (__isRecord(__script.layout) && Object.keys(__script.layout).length > 0) __layouts.push(__script.layout);
+        else if (!("namespace" in __script) && !("g" in __script) && !("layout" in __script) && __isRenderableTree(__script)) {
+          const { slex: __slex, ...__layout } = __script;
+          __layouts.push(__layout);
+        }
+      }
+      if (__layouts.length === 1) {
+        __target.layout = { "column:block_0": Object.assign({}, __layouts[0], { id: "slexkit-slot-slot_0" }) };
+      } else if (__layouts.length > 1) {
+        __target.layout = {
+          "column:artifact": Object.fromEntries(
+            __layouts.map((layout, index) => ["column:block_" + index, Object.assign({}, layout, { id: "slexkit-slot-slot_" + index })]),
+          ),
+        };
+      }
+      return __target;
+    })()`;
+  }
+  function addArtifactContainer(artifactId, container) {
+    let containers = artifactContainers.get(artifactId);
+    if (!containers) {
+      containers = new Set;
+      artifactContainers.set(artifactId, containers);
+    }
+    containers.add(container);
+  }
+  function addArtifactSource(block) {
+    const artifactId = block.artifactId;
+    let sources = artifactSources.get(artifactId);
+    if (!sources) {
+      sources = new Map;
+      artifactSources.set(artifactId, sources);
+    }
+    sources.set(block.container, block.source);
+    addArtifactContainer(artifactId, block.container);
+    return artifactId;
+  }
+  function clearSecureSlot(container) {
+    delete container.dataset.slexkitSecureArtifactSlot;
+    container.replaceChildren();
+  }
+  function selectSecureArtifactAnchor(artifactId) {
+    const containers = artifactContainers.get(artifactId);
+    if (!containers?.size)
+      return;
+    return Array.from(containers).sort(compareDocumentOrder)[0];
+  }
+  function remountSecureArtifact(artifactId, theme) {
+    const anchor = secureArtifactAnchors.get(artifactId);
+    if (!anchor)
+      return;
+    secureArtifactCleanups.get(artifactId)?.();
+    secureArtifactCleanups.delete(artifactId);
+    clearSecureSlot(anchor);
+    const containers = artifactContainers.get(artifactId) ?? new Set;
+    const orderedContainers = Array.from(containers).sort(compareDocumentOrder);
+    for (const container of containers) {
+      if (container === anchor)
+        continue;
+      clearSecureSlot(container);
+      container.dataset.slexkitSecureArtifactSlot = "true";
+    }
+    const cleanup = mountSecureArtifact(composeSecureArtifactSource(artifactId), anchor, {
+      theme,
+      dir: options.dir,
+      labels: options.labels,
+      policy: options.policy ?? DEFAULT_POLICY,
+      hostAdapter: options.hostAdapter,
+      frame: options.secureFrame ?? true,
+      artifactSlots: orderedContainers.map((container, index) => ({
+        id: `slot_${index}`,
+        container
+      }))
+    });
+    secureArtifactCleanups.set(artifactId, cleanup);
+  }
+  function mountSecureBlock(block) {
+    if (!block.artifactId) {
+      const cleanup2 = mountSecureArtifact(block.source, block.container, {
+        theme: block.theme ?? options.theme,
+        dir: block.dir ?? options.dir,
+        labels: block.labels ?? options.labels,
+        policy: options.policy ?? DEFAULT_POLICY,
+        hostAdapter: options.hostAdapter,
+        frame: options.secureFrame ?? true
+      });
+      return remember(block, cleanup2);
+    }
+    const artifactId = addArtifactSource(block);
+    const anchor = selectSecureArtifactAnchor(artifactId);
+    if (anchor)
+      secureArtifactAnchors.set(artifactId, anchor);
+    remountSecureArtifact(artifactId, block.theme ?? options.theme);
+    const cleanup = () => {
+      artifactSources.get(artifactId)?.delete(block.container);
+      artifactContainers.get(artifactId)?.delete(block.container);
+      cleanups.delete(block.container);
+      clearSecureSlot(block.container);
+      const sources = artifactSources.get(artifactId);
+      const containers = artifactContainers.get(artifactId);
+      if (!sources?.size || !containers?.size) {
+        secureArtifactCleanups.get(artifactId)?.();
+        secureArtifactCleanups.delete(artifactId);
+        secureArtifactAnchors.delete(artifactId);
+        artifactSources.delete(artifactId);
+        artifactContainers.delete(artifactId);
+        return;
+      }
+      if (secureArtifactAnchors.get(artifactId) === block.container) {
+        const nextAnchor = selectSecureArtifactAnchor(artifactId);
+        if (nextAnchor)
+          secureArtifactAnchors.set(artifactId, nextAnchor);
+      }
+      remountSecureArtifact(artifactId, block.theme ?? options.theme);
+    };
+    cleanups.set(block.container, cleanup);
+    return cleanup;
+  }
+  function remember(block, cleanup) {
+    cleanups.set(block.container, cleanup);
+    if (block.artifactId) {
+      addArtifactContainer(block.artifactId, block.container);
+    }
+    return () => {
+      cleanup();
+      cleanups.delete(block.container);
+      if (!block.artifactId)
+        return;
+      const containers = artifactContainers.get(block.artifactId);
+      containers?.delete(block.container);
+      if (containers?.size === 0)
+        artifactContainers.delete(block.artifactId);
+    };
+  }
+  function disposeBlock(container) {
+    const cleanup = cleanups.get(container);
+    if (!cleanup)
+      return;
+    cleanup();
+    cleanups.delete(container);
+    for (const [artifactId, containers] of artifactContainers) {
+      containers.delete(container);
+      artifactSources.get(artifactId)?.delete(container);
+      if (secureArtifactAnchors.get(artifactId) === container) {
+        const nextAnchor = selectSecureArtifactAnchor(artifactId);
+        if (nextAnchor)
+          secureArtifactAnchors.set(artifactId, nextAnchor);
+        else
+          secureArtifactAnchors.delete(artifactId);
+      }
+      if (containers.size === 0)
+        artifactContainers.delete(artifactId);
+      if (artifactSources.get(artifactId)?.size === 0)
+        artifactSources.delete(artifactId);
+    }
+  }
+  return {
+    configure(nextOptions) {
+      options = { ...options, ...nextOptions };
+    },
+    getMode() {
+      return options.mode ?? "trusted";
+    },
+    mountBlock(block) {
+      disposeBlock(block.container);
+      block.container.replaceChildren();
+      const mode = options.mode ?? "trusted";
+      if (mode === "secure")
+        return mountSecureBlock(block);
+      const parsedSource = parseTrustedSource(block.source);
+      rememberTrustedArtifactNamespace(block.artifactId, parsedSource);
+      const trustedSource = scopedTrustedSource(parsedSource, block.artifactId);
+      const stateOnly = block.stateOnly ?? isStateOnlySource(trustedSource);
+      if (stateOnly) {
+        const ok = ingest(trustedSource);
+        if (!ok)
+          throw new Error("Failed to parse Slex state block.");
+        return remember(block, () => {});
+      }
+      const theme = block.theme ?? options.theme;
+      const cleanup = mount(trustedSource, block.container, {
+        theme,
+        dir: block.dir ?? options.dir,
+        labels: block.labels ?? options.labels
+      });
+      return remember(block, cleanup);
+    },
+    disposeBlock,
+    disposeArtifact(artifactId) {
+      const containers = Array.from(artifactContainers.get(artifactId) ?? []);
+      for (const container of containers)
+        disposeBlock(container);
+      secureArtifactCleanups.get(artifactId)?.();
+      secureArtifactCleanups.delete(artifactId);
+      secureArtifactAnchors.delete(artifactId);
+      artifactContainers.delete(artifactId);
+      artifactSources.delete(artifactId);
+      disposeTrustedArtifactNamespaces(artifactId);
+    },
+    disposeAll() {
+      for (const container of Array.from(cleanups.keys()))
+        disposeBlock(container);
+      for (const cleanup of Array.from(secureArtifactCleanups.values()))
+        cleanup();
+      secureArtifactCleanups.clear();
+      secureArtifactAnchors.clear();
+      artifactContainers.clear();
+      artifactSources.clear();
+      for (const artifactId of Array.from(trustedArtifactNamespaces.keys())) {
+        disposeTrustedArtifactNamespaces(artifactId);
+      }
+    }
+  };
+}
+var globalMarkdownRuntimeHost;
+function installSlexKitMarkdownRuntimeHost(options = {}) {
+  globalMarkdownRuntimeHost = createSlexKitMarkdownRuntimeHost(options);
+  return globalMarkdownRuntimeHost;
+}
+function getSlexKitMarkdownRuntimeHost() {
+  if (!globalMarkdownRuntimeHost) {
+    globalMarkdownRuntimeHost = createSlexKitMarkdownRuntimeHost();
+  }
+  return globalMarkdownRuntimeHost;
+}
+
+// src/engine/index.ts
+var defaultRuntimeUrl = typeof document !== "undefined" && typeof document.currentScript === "object" && document.currentScript && "src" in document.currentScript ? String(document.currentScript.src || "") : undefined;
+function setSlexKitRuntimeUrl(url) {
+  defaultRuntimeUrl = url || undefined;
+}
+function getSlexKitRuntimeUrl() {
+  return defaultRuntimeUrl;
+}
+function normalizeExpression(input) {
+  if (!input || typeof input !== "object")
+    return input;
+  const hasProtocolMarker = "slex" in input;
+  const hasEnvelopeField = "namespace" in input || "g" in input || "layout" in input;
+  if (hasEnvelopeField)
+    return input;
+  const keys = Object.keys(input);
+  if (keys.some((key) => key.includes(":"))) {
+    const { slex, ...layout } = input;
+    return {
+      ...hasProtocolMarker ? { slex } : {},
+      namespace: "default",
+      g: {},
+      layout
+    };
+  }
+  return input;
+}
+function warnUnsupportedProtocol(expression) {
+  if (expression.slex === undefined || expression.slex === SLEX_PROTOCOL_VERSION)
+    return;
+  console.warn(`[SlexKit] Slex protocol marker '${String(expression.slex)}' does not match supported protocol '${SLEX_PROTOCOL_VERSION}'.`);
+}
+function parseSourceOrExpression(input) {
+  if (typeof input !== "string")
+    return normalizeExpression(input);
+  const parsed = parseSlexSource(input);
+  if (!parsed.ok) {
+    console.warn("[SlexKit] Failed to parse Slex source:", parsed.error.message);
+    return;
+  }
+  return normalizeExpression(parsed.value);
+}
+function applyExpression(expression) {
+  warnUnsupportedProtocol(expression);
+  const ns = expression.namespace || "default";
+  const store = getStore(ns);
+  if (expression.g) {
+    try {
+      deepMerge(store.g, expression.g);
+    } catch (e) {
+      console.warn(`[SlexKit][${ns}] Merge error, replacing entire g:`, e.message);
+      for (const k of Object.keys(store.g)) {
+        delete store.g[k];
+      }
+      Object.assign(store.g, expression.g);
+    }
+  }
+  if (expression.layout) {
+    store.layouts = [expression.layout];
+  }
+}
+function hasThemeToken(el, token) {
+  return getComputedStyle(el).getPropertyValue(token).trim().length > 0;
+}
+function resolveThemeMode(container, requested = "auto") {
+  if (requested !== "auto")
+    return requested;
+  if (container.closest(".slexkit-theme-uno, .slexkit-theme-flowbite"))
+    return "uno";
+  return hasThemeToken(container, "--primary") && hasThemeToken(container, "--background") ? "host-shadcn" : "uno";
+}
+function resolveColorMode(container) {
+  const scoped = container.closest(".dark, .light, [data-theme='dark'], [data-theme='light']");
+  if (scoped?.classList.contains("dark") || scoped?.dataset.theme === "dark")
+    return "dark";
+  if (scoped?.classList.contains("light") || scoped?.dataset.theme === "light")
+    return "light";
+  const doc = container.ownerDocument || document;
+  const docEl = doc.documentElement;
+  if (docEl.classList.contains("dark") || docEl.dataset.theme === "dark")
+    return "dark";
+  if (docEl.classList.contains("light") || docEl.dataset.theme === "light")
+    return "light";
+  const scheme = getComputedStyle(docEl).colorScheme || getComputedStyle(container).colorScheme;
+  if (scheme.split(/\s+/).includes("dark"))
+    return "dark";
+  if (scheme.split(/\s+/).includes("light"))
+    return "light";
+  return;
+}
+function applyDocumentColorMode(doc, mode) {
+  if (!mode)
+    return;
+  doc.documentElement.classList.toggle("dark", mode === "dark");
+  doc.documentElement.classList.toggle("light", mode === "light");
+  doc.documentElement.dataset.theme = mode;
+}
+function resolveDirection(container, requested = "auto") {
+  if (requested === "ltr" || requested === "rtl")
+    return requested;
+  const inherited = container.closest("[dir]")?.dir || container.ownerDocument?.documentElement?.dir;
+  return inherited === "rtl" ? "rtl" : "ltr";
+}
+function mount(input, container, options = {}) {
+  const expression = parseSourceOrExpression(input);
+  if (!expression)
+    return () => {};
+  const ns = expression.namespace || "default";
+  const store = getStore(ns);
+  const ownerDocument = container.ownerDocument || document;
+  applyExpression(expression);
+  const oldCleanup = store.cleanups.get(container);
+  if (oldCleanup)
+    oldCleanup();
+  const root = ownerDocument.createElement("div");
+  const theme = resolveThemeMode(container, options.theme);
+  const dir = resolveDirection(container, options.dir);
+  root.className = `slexkit-root slexkit-theme-${theme}`;
+  root.dir = dir;
+  root.dataset.namespace = ns;
+  root.dataset.theme = theme;
+  root.dataset.dir = dir;
+  container.appendChild(root);
+  store.roots.set(container, root);
+  const cleanup = createRoot((dispose) => {
+    const layoutRoot = ownerDocument.createElement("div");
+    layoutRoot.className = "slex-layout";
+    root.appendChild(layoutRoot);
+    renderTree(expression.layout ?? {}, layoutRoot, store.g, store.components, store.componentTypes, undefined, ns, options.api, {
+      dir,
+      labels: options.labels ?? {}
+    });
+    return () => {
+      dispose();
+      root.remove();
+      store.roots.delete(container);
+      store.cleanups.delete(container);
+    };
+  });
+  store.cleanups.set(container, cleanup);
+  return cleanup;
+}
+function disposeNamespace(namespace) {
+  const ns = namespace || "default";
+  const store = peekStore(ns);
+  if (store) {
+    for (const cleanup of Array.from(store.cleanups.values())) {
+      try {
+        cleanup();
+      } catch (e) {
+        console.warn(`[SlexKit][${ns}] Cleanup error while disposing namespace:`, e.message);
+      }
+    }
+    for (const root of Array.from(store.roots.values())) {
+      root.remove();
+    }
+    store.roots.clear();
+    store.cleanups.clear();
+    deleteStore(ns);
+  }
+  clearEvalCache(ns);
+}
+function mountSecureArtifact(input, container, options) {
+  container.dataset.slexkitSecureRuntime = "true";
+  let frameTarget;
+  try {
+    frameTarget = createSecureFrameTarget(input, container, options);
+  } catch (error) {
+    delete container.dataset.slexkitSecureRuntime;
+    throw error;
+  }
+  if (frameTarget?.sandboxed) {
+    return () => {
+      frameTarget.dispose();
+      delete container.dataset.slexkitSecureRuntime;
+    };
+  }
+  if (!options.unsafeInlineExecution) {
+    delete container.dataset.slexkitSecureRuntime;
+    throw new Error("mountSecureArtifact requires a sandbox frame runtime URL. Use unsafeInlineExecution only for trusted inline execution.");
+  }
+  const runtime = createSecureRuntime(options.policy, options.hostAdapter);
+  const target = frameTarget?.target ?? container;
+  const cleanup = mount(input, target, {
+    theme: options.theme,
+    dir: options.dir,
+    labels: options.labels,
+    api: runtime.api
+  });
+  return () => {
+    cleanup();
+    runtime.dispose();
+    frameTarget?.dispose();
+    delete container.dataset.slexkitSecureRuntime;
+  };
+}
+function createSecureFrameTarget(input, container, mountOptions) {
+  const frame = mountOptions.frame;
+  if (!frame)
+    return null;
+  const ownerDocument = container.ownerDocument || document;
+  const options = typeof frame === "object" ? frame : {};
+  const iframe = ownerDocument.createElement("iframe");
+  iframe.className = options.className ?? "slexkit-secure-frame";
+  iframe.title = options.title ?? "SlexKit secure artifact";
+  iframe.setAttribute("data-slexkit-secure-frame", "true");
+  iframe.setAttribute("referrerpolicy", "no-referrer");
+  const runtimeUrl = options.runtimeUrl ?? options.runnerUrl ?? defaultRuntimeUrl;
+  if (runtimeUrl) {
+    const resolvedRuntimeUrl = resolveRuntimeUrl(runtimeUrl);
+    assertSandboxCloneable(input);
+    iframe.setAttribute("sandbox", secureSandboxAttribute(options));
+    container.replaceChildren(iframe);
+    const bridge = createSandboxBridge(input, container, iframe, mountOptions);
+    iframe.srcdoc = secureRunnerSrcdoc(resolvedRuntimeUrl);
+    return bridge;
+  }
+  if (frame) {
+    iframe.remove();
+    throw new Error("SlexKit secure frame requires runtimeUrl or setSlexKitRuntimeUrl().");
+  }
+  if (options.sandbox)
+    iframe.setAttribute("sandbox", options.sandbox);
+  container.replaceChildren(iframe);
+  const frameDocument = iframe.contentDocument;
+  if (!frameDocument?.body) {
+    iframe.remove();
+    throw new Error("Unable to create SlexKit secure frame document.");
+  }
+  frameDocument.open();
+  frameDocument.write('<!doctype html><html><head></head><body><div id="slexkit-secure-root"></div></body></html>');
+  frameDocument.close();
+  applyDocumentColorMode(frameDocument, resolveColorMode(container));
+  const target = frameDocument.getElementById("slexkit-secure-root");
+  if (!target) {
+    iframe.remove();
+    throw new Error("Unable to create SlexKit secure frame root.");
+  }
+  return {
+    target,
+    dispose: () => iframe.remove()
+  };
+}
+function secureSandboxAttribute(options) {
+  const sandbox = options.sandbox ?? "allow-scripts";
+  const tokens = sandbox.split(/\s+/).filter(Boolean);
+  if (tokens.includes("allow-same-origin") && !options.unsafeAllowSameOrigin) {
+    throw new Error("SlexKit secure frames cannot use allow-same-origin unless unsafeAllowSameOrigin is explicitly enabled.");
+  }
+  if (!tokens.includes("allow-scripts")) {
+    throw new Error("SlexKit secure frames require allow-scripts to run the runtime.");
+  }
+  return tokens.join(" ");
+}
+function resolveRuntimeUrl(runtimeUrl) {
+  try {
+    const base = typeof document !== "undefined" ? document.baseURI : undefined;
+    return new URL(runtimeUrl, base).href;
+  } catch {
+    return runtimeUrl;
+  }
+}
+function cspSourceForRuntime(runtimeUrl) {
+  try {
+    const parsed = new URL(runtimeUrl);
+    if (parsed.protocol === "blob:")
+      return "blob:";
+    if (parsed.protocol === "data:")
+      return "data:";
+    return parsed.origin;
+  } catch {
+    return "'self'";
+  }
+}
+function escapeHtmlAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function secureRunnerSrcdoc(runtimeUrl) {
+  const nonce = randomToken(12);
+  const csp = [
+    "default-src 'none'",
+    `script-src 'nonce-${nonce}' 'unsafe-eval' ${cspSourceForRuntime(runtimeUrl)}`,
+    "connect-src 'none'",
+    "img-src data: blob:",
+    "style-src 'unsafe-inline'",
+    "font-src data:",
+    "form-action 'none'",
+    "base-uri 'none'"
+  ].join("; ");
+  const style = "html,body{margin:0;min-height:100%;overflow:hidden;}#slexkit-secure-root{min-height:100%;}";
+  return `<!doctype html><html><head><meta charset="utf-8"><meta http-equiv="Content-Security-Policy" content="${escapeHtmlAttribute(csp)}"><style>${style}</style></head><body><div id="slexkit-secure-root"></div><script type="module" nonce="${nonce}">import { startSlexKitSandboxRunner } from ${JSON.stringify(runtimeUrl)}; startSlexKitSandboxRunner();</script></body></html>`;
+}
+function secureFrameLoadTimeout(options) {
+  const frame = options.frame;
+  if (frame && typeof frame === "object" && typeof frame.loadTimeoutMs === "number") {
+    return Math.max(0, frame.loadTimeoutMs);
+  }
+  return 8000;
+}
+function secureFrameMaxUnresponsiveMs(options) {
+  const value = options.policy.execution?.maxUnresponsiveMs;
+  return typeof value === "number" ? Math.max(0, value) : 0;
+}
+function secureFrameLoadError(runtimeUrl, phase, detail) {
+  const phaseMessage = phase === "ready" ? "The sandbox did not report that the runtime module loaded." : "The sandbox loaded but did not confirm artifact mount.";
+  const suffix = detail ? `
+Sandbox error: ${detail}` : "";
+  return new Error(`SlexKit secure runtime failed to load.
+${phaseMessage}
+Runtime URL: ${runtimeUrl}
+` + `Check that this URL serves slexkit.runtime.js as an ES module with:
+` + `Access-Control-Allow-Origin: *
+Content-Type: text/javascript
+` + "Do not fix this by adding allow-same-origin to the sandbox frame." + suffix);
+}
+function secureFrameHeartbeatError(runtimeUrl, elapsedMs) {
+  return new Error(`SlexKit secure runtime stopped responding.
+` + `No sandbox heartbeat was received for ${Math.round(elapsedMs)} ms.
+` + `Runtime URL: ${runtimeUrl}
+` + "The sandbox frame was terminated to avoid keeping unresponsive agent code alive.");
+}
+function showSecureFrameError(container, iframe, error) {
+  container.dataset.slexkitSecureStatus = "error";
+  let alert = container.querySelector(".slexkit-secure-error");
+  if (!alert) {
+    alert = (container.ownerDocument || document).createElement("div");
+    alert.className = "slexkit-secure-error";
+    alert.setAttribute("role", "alert");
+    iframe.after(alert);
+  }
+  alert.textContent = error.message;
+  console.error(error.message);
+}
+function clearSecureFrameError(container) {
+  delete container.dataset.slexkitSecureStatus;
+  container.querySelector(".slexkit-secure-error")?.remove();
+}
+function assertSandboxCloneable(input) {
+  if (typeof input === "string")
+    return;
+  const seen = new Set;
+  const visit = (value) => {
+    if (typeof value === "function") {
+      throw new Error("Sandbox runner input cannot contain functions. Pass Slex source to execute functions inside the sandbox realm.");
+    }
+    if (!value || typeof value !== "object")
+      return;
+    if (seen.has(value))
+      return;
+    seen.add(value);
+    for (const item of Object.values(value))
+      visit(item);
+  };
+  visit(input);
+}
+function createSandboxBridge(input, container, iframe, options) {
+  const id = `secure_${randomToken(8)}`;
+  const token = randomToken(24);
+  const bridgeRuntime = createSecureRuntime(options.policy, options.hostAdapter);
+  const runtimeUrl = typeof options.frame === "object" ? resolveRuntimeUrl(options.frame.runtimeUrl ?? options.frame.runnerUrl ?? defaultRuntimeUrl ?? "") : resolveRuntimeUrl(defaultRuntimeUrl ?? "");
+  const loadTimeoutMs = secureFrameLoadTimeout(options);
+  const artifactSlots = normalizeArtifactSlots(options.artifactSlots);
+  let disposed = false;
+  let mounted = false;
+  let ready = false;
+  let mountAcknowledged = false;
+  let loadTimer;
+  let heartbeatTimer;
+  let slotSyncFrame;
+  let slotSyncTimer;
+  let lastHeartbeat = 0;
+  const maxUnresponsiveMs = secureFrameMaxUnresponsiveMs(options);
+  const ownerWindow = iframe.ownerDocument.defaultView ?? window;
+  const slotStyleSnapshots = new Map;
+  let adjustedAnchorPosition = false;
+  const clearLoadTimer = () => {
+    if (loadTimer === undefined)
+      return;
+    window.clearTimeout(loadTimer);
+    loadTimer = undefined;
+  };
+  const clearHeartbeatTimer = () => {
+    if (heartbeatTimer === undefined)
+      return;
+    window.clearInterval(heartbeatTimer);
+    heartbeatTimer = undefined;
+  };
+  const failLoad = (phase, detail) => {
+    if (disposed || mountAcknowledged)
+      return;
+    clearLoadTimer();
+    showSecureFrameError(container, iframe, secureFrameLoadError(runtimeUrl, phase, detail));
+    terminateFrame({ keepDiagnostic: true });
+  };
+  const failHeartbeat = () => {
+    if (disposed || !mountAcknowledged || maxUnresponsiveMs <= 0)
+      return;
+    const elapsed = Date.now() - lastHeartbeat;
+    if (elapsed < maxUnresponsiveMs)
+      return;
+    clearHeartbeatTimer();
+    showSecureFrameError(container, iframe, secureFrameHeartbeatError(runtimeUrl, elapsed));
+    terminateFrame({ keepDiagnostic: true });
+  };
+  const startHeartbeatWatchdog = () => {
+    if (maxUnresponsiveMs <= 0 || heartbeatTimer !== undefined)
+      return;
+    lastHeartbeat = Date.now();
+    heartbeatTimer = window.setInterval(failHeartbeat, Math.max(10, Math.min(1000, maxUnresponsiveMs / 2)));
+  };
+  const clearSlotSyncTimer = () => {
+    if (slotSyncFrame !== undefined) {
+      ownerWindow.cancelAnimationFrame(slotSyncFrame);
+      slotSyncFrame = undefined;
+    }
+    if (slotSyncTimer !== undefined) {
+      ownerWindow.clearTimeout(slotSyncTimer);
+      slotSyncTimer = undefined;
+    }
+  };
+  const syncArtifactSlotsNow = () => {
+    slotSyncFrame = undefined;
+    slotSyncTimer = undefined;
+    if (!artifactSlots.length || disposed)
+      return;
+    const frameRect = iframe.getBoundingClientRect();
+    const slots = artifactSlots.map((slot) => {
+      const rect = slot.container.getBoundingClientRect();
+      return {
+        id: slot.id,
+        left: rect.left - frameRect.left,
+        top: rect.top - frameRect.top,
+        width: rect.width,
+        height: rect.height
+      };
+    });
+    if (artifactSlots.length > 1) {
+      const maxBottom = Math.max(1, ...slots.map((slot) => slot.top + slot.height));
+      iframe.style.height = `${Math.ceil(maxBottom)}px`;
+    }
+    iframe.contentWindow?.postMessage({
+      channel: "slexkit-secure",
+      type: "slots",
+      id,
+      token,
+      slots
+    }, "*");
+  };
+  const requestArtifactSlotSync = () => {
+    if (!artifactSlots.length || disposed || slotSyncFrame !== undefined || slotSyncTimer !== undefined)
+      return;
+    if (typeof ownerWindow.requestAnimationFrame === "function") {
+      slotSyncFrame = ownerWindow.requestAnimationFrame(syncArtifactSlotsNow);
+    } else {
+      slotSyncTimer = ownerWindow.setTimeout(syncArtifactSlotsNow, 0);
+    }
+  };
+  const slotResizeObserver = artifactSlots.length && typeof ResizeObserver !== "undefined" ? new ResizeObserver(requestArtifactSlotSync) : undefined;
+  if (artifactSlots.length > 1) {
+    slotStyleSnapshots.set(container, {
+      minHeight: container.style.minHeight,
+      position: container.style.position,
+      secureSlotId: container.dataset.slexkitSecureArtifactSlotId
+    });
+    iframe.style.position = "absolute";
+    iframe.style.inset = "0 auto auto 0";
+    iframe.style.width = "100%";
+    iframe.style.minHeight = "1px";
+    iframe.style.border = "0";
+    iframe.style.background = "transparent";
+    iframe.style.zIndex = "1";
+    iframe.setAttribute("allowtransparency", "true");
+    const computedAnchorPosition = ownerWindow.getComputedStyle(container).position;
+    if (!computedAnchorPosition || computedAnchorPosition === "static") {
+      container.style.position = "relative";
+      adjustedAnchorPosition = true;
+    }
+  }
+  for (const slot of artifactSlots) {
+    if (!slotStyleSnapshots.has(slot.container)) {
+      slotStyleSnapshots.set(slot.container, {
+        minHeight: slot.container.style.minHeight,
+        position: slot.container.style.position,
+        secureSlotId: slot.container.dataset.slexkitSecureArtifactSlotId
+      });
+    }
+    slot.container.dataset.slexkitSecureArtifactSlotId = slot.id;
+    slotResizeObserver?.observe(slot.container);
+  }
+  if (artifactSlots.length) {
+    ownerWindow.addEventListener("resize", requestArtifactSlotSync);
+    ownerWindow.addEventListener("scroll", requestArtifactSlotSync, true);
+  }
+  if (loadTimeoutMs > 0) {
+    loadTimer = window.setTimeout(() => {
+      failLoad(ready ? "mounted" : "ready");
+    }, loadTimeoutMs);
+  }
+  const postMount = () => {
+    if (mounted)
+      return;
+    mounted = true;
+    iframe.contentWindow?.postMessage({
+      channel: "slexkit-secure",
+      type: "mount",
+      id,
+      token,
+      input,
+      policy: options.policy,
+      theme: options.theme,
+      colorMode: resolveColorMode(container),
+      dir: options.dir,
+      labels: options.labels
+    }, "*");
+  };
+  const onMessage = (event) => {
+    if (disposed || event.source !== iframe.contentWindow)
+      return;
+    const data = event.data;
+    if (!data || data.channel !== "slexkit-secure")
+      return;
+    if (data.type === "ready") {
+      ready = true;
+      postMount();
+      return;
+    }
+    if (data.type === "mounted" && data.id === id && data.token === token) {
+      mountAcknowledged = true;
+      lastHeartbeat = Date.now();
+      clearLoadTimer();
+      clearSecureFrameError(container);
+      startHeartbeatWatchdog();
+      syncArtifactSlotsNow();
+      return;
+    }
+    if (data.type === "heartbeat" && data.id === id && data.token === token) {
+      lastHeartbeat = Date.now();
+      return;
+    }
+    if (data.type === "slot-size" && data.id === id && data.token === token && typeof data.slotId === "string") {
+      const slot = artifactSlots.find((item) => item.id === data.slotId);
+      if (slot && typeof data.height === "number" && Number.isFinite(data.height)) {
+        slot.container.style.minHeight = `${Math.max(0, Math.ceil(data.height))}px`;
+        requestArtifactSlotSync();
+      }
+      return;
+    }
+    if (data.type === "error" && (!data.id || data.id === id) && (!data.token || data.token === token)) {
+      const error = data;
+      failLoad(ready ? "mounted" : "ready", typeof error.error?.message === "string" ? error.error.message : undefined);
+      return;
+    }
+    if (data.type !== "fetch" || data.id !== id || data.token !== token || typeof data.requestId !== "string")
+      return;
+    const request = validateSandboxFetchRequest(data.request);
+    if (!request)
+      return;
+    bridgeRuntime.api.fetch(request.url, request).then((result) => {
+      iframe.contentWindow?.postMessage({
+        channel: "slexkit-secure",
+        type: "fetch-result",
+        id,
+        token,
+        requestId: data.requestId,
+        result
+      }, "*");
+    }).catch((error) => {
+      iframe.contentWindow?.postMessage({
+        channel: "slexkit-secure",
+        type: "fetch-result",
+        id,
+        token,
+        requestId: data.requestId,
+        error: serializeRuntimeError(error)
+      }, "*");
+    });
+  };
+  window.addEventListener("message", onMessage);
+  const terminateFrame = ({ keepDiagnostic = false } = {}) => {
+    if (disposed)
+      return;
+    disposed = true;
+    iframe.contentWindow?.postMessage({
+      channel: "slexkit-secure",
+      type: "dispose",
+      id,
+      token
+    }, "*");
+    clearLoadTimer();
+    clearHeartbeatTimer();
+    clearSlotSyncTimer();
+    slotResizeObserver?.disconnect();
+    if (artifactSlots.length) {
+      ownerWindow.removeEventListener("resize", requestArtifactSlotSync);
+      ownerWindow.removeEventListener("scroll", requestArtifactSlotSync, true);
+    }
+    for (const slot of artifactSlots) {
+      const snapshot = slotStyleSnapshots.get(slot.container);
+      if (snapshot) {
+        if (snapshot.secureSlotId === undefined)
+          delete slot.container.dataset.slexkitSecureArtifactSlotId;
+        else
+          slot.container.dataset.slexkitSecureArtifactSlotId = snapshot.secureSlotId;
+        slot.container.style.minHeight = snapshot.minHeight;
+      } else {
+        delete slot.container.dataset.slexkitSecureArtifactSlotId;
+        slot.container.style.removeProperty("min-height");
+      }
+    }
+    if (adjustedAnchorPosition)
+      container.style.position = slotStyleSnapshots.get(container)?.position ?? "";
+    window.removeEventListener("message", onMessage);
+    bridgeRuntime.dispose();
+    iframe.remove();
+    if (!keepDiagnostic)
+      clearSecureFrameError(container);
+    if (!container.hasChildNodes())
+      container.replaceChildren();
+  };
+  return {
+    sandboxed: true,
+    dispose: () => terminateFrame()
+  };
+}
+function normalizeArtifactSlots(slots) {
+  if (!slots?.length)
+    return [];
+  const seen = new Set;
+  const normalized = [];
+  for (const slot of slots) {
+    const id = String(slot.id || "").trim();
+    if (!id || seen.has(id) || !slot.container)
+      continue;
+    seen.add(id);
+    normalized.push({ id, container: slot.container });
+  }
+  return normalized;
+}
+function randomToken(bytes) {
+  const cryptoApi = globalThis.crypto;
+  if (cryptoApi?.getRandomValues) {
+    const values = new Uint8Array(bytes);
+    cryptoApi.getRandomValues(values);
+    return Array.from(values, (value) => value.toString(16).padStart(2, "0")).join("");
+  }
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2)}`;
+}
+function validateSandboxFetchRequest(value) {
+  if (!value || typeof value !== "object")
+    return null;
+  const request = value;
+  if (typeof request.url !== "string")
+    return null;
+  if (request.method !== "GET" && request.method !== "POST")
+    return null;
+  if (request.credentials !== "omit" && request.credentials !== "same-origin" && request.credentials !== "include")
+    return null;
+  if (typeof request.timeoutMs !== "number" || !Number.isFinite(request.timeoutMs) || request.timeoutMs <= 0)
+    return null;
+  if (request.headers !== undefined && !isStringRecord(request.headers))
+    return null;
+  return {
+    url: request.url,
+    method: request.method,
+    headers: request.headers,
+    body: request.body,
+    credentials: request.credentials,
+    timeoutMs: request.timeoutMs
+  };
+}
+function isStringRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  return Object.values(value).every((item) => typeof item === "string");
+}
+function ingest(input) {
+  const expression = parseSourceOrExpression(input);
+  if (!expression)
+    return false;
+  applyExpression(expression);
+  return true;
+}
+function copyText(text) {
+  if (navigator.clipboard?.writeText) {
+    navigator.clipboard.writeText(text);
+    return;
+  }
+  const textarea = document.createElement("textarea");
+  textarea.value = text;
+  textarea.setAttribute("readonly", "");
+  textarea.style.position = "fixed";
+  textarea.style.opacity = "0";
+  document.body.appendChild(textarea);
+  textarea.select();
+  document.execCommand("copy");
+  textarea.remove();
+}
+function mountBootPreview(source, host, options) {
+  host.replaceChildren();
+  const preview = document.createElement("div");
+  preview.className = "slexkit-preview";
+  host.appendChild(preview);
+  return mount(source, preview, options);
+}
+function addSourceControls(pre, host, remount) {
+  const toolbar = document.createElement("div");
+  toolbar.className = "slexkit-source-toolbar";
+  const copyButton = document.createElement("button");
+  copyButton.type = "button";
+  copyButton.className = "slexkit-source-button";
+  copyButton.textContent = "Copy source";
+  copyButton.addEventListener("click", () => copyText(pre.textContent || ""));
+  const viewButton = document.createElement("button");
+  viewButton.type = "button";
+  viewButton.className = "slexkit-source-button";
+  viewButton.textContent = "Hide source";
+  viewButton.addEventListener("click", () => {
+    pre.hidden = !pre.hidden;
+    viewButton.textContent = pre.hidden ? "View source" : "Hide source";
+  });
+  const renderButton = document.createElement("button");
+  renderButton.type = "button";
+  renderButton.className = "slexkit-source-button";
+  renderButton.textContent = "Re-render";
+  renderButton.addEventListener("click", remount);
+  toolbar.append(copyButton, viewButton, renderButton);
+  host.parentNode?.insertBefore(toolbar, host);
+}
+function boot(options = {}) {
+  const selector = options.selector || "pre code.language-slex";
+  document.querySelectorAll(selector).forEach((el) => {
+    if (el.dataset.slexkitBooted === "true")
+      return;
+    el.dataset.slexkitBooted = "true";
+    const source = el.textContent || "";
+    const pre = el.closest("pre");
+    const host = document.createElement("div");
+    host.className = "slexkit-card";
+    if (pre)
+      pre.parentNode.insertBefore(host, pre.nextSibling);
+    else
+      el.parentNode.insertBefore(host, el.nextSibling);
+    let cleanup = mountBootPreview(source, host, { theme: options.theme, dir: options.dir, labels: options.labels });
+    const remount = () => {
+      cleanup();
+      cleanup = mountBootPreview(el.textContent || "", host, { theme: options.theme, dir: options.dir, labels: options.labels });
+    };
+    if (pre && options.sourceControls !== false) {
+      addSourceControls(pre, host, remount);
+    }
+  });
+}
+
+// src/engine/sandbox-runner.ts
+var schedulingSnapshot = {
+  setTimeout: typeof globalThis.setTimeout === "function" ? globalThis.setTimeout.bind(globalThis) : undefined,
+  clearTimeout: typeof globalThis.clearTimeout === "function" ? globalThis.clearTimeout.bind(globalThis) : undefined,
+  setInterval: typeof globalThis.setInterval === "function" ? globalThis.setInterval.bind(globalThis) : undefined,
+  clearInterval: typeof globalThis.clearInterval === "function" ? globalThis.clearInterval.bind(globalThis) : undefined,
+  requestAnimationFrame: typeof globalThis.requestAnimationFrame === "function" ? globalThis.requestAnimationFrame.bind(globalThis) : undefined,
+  cancelAnimationFrame: typeof globalThis.cancelAnimationFrame === "function" ? globalThis.cancelAnimationFrame.bind(globalThis) : undefined
+};
+function isHostMessage(value) {
+  return !!value && typeof value === "object" && value.channel === "slexkit-secure" && typeof value.type === "string";
+}
+function frameRoot() {
+  let root = document.getElementById("slexkit-secure-root");
+  if (!root) {
+    root = document.createElement("div");
+    root.id = "slexkit-secure-root";
+    document.body.appendChild(root);
+  }
+  return root;
+}
+function applyColorMode(mode) {
+  if (mode !== "dark" && mode !== "light")
+    return;
+  document.documentElement.classList.toggle("dark", mode === "dark");
+  document.documentElement.classList.toggle("light", mode === "light");
+  document.documentElement.dataset.theme = mode;
+}
+function post(message) {
+  window.parent?.postMessage(message, "*");
+}
+function createBridgeAdapter(id, token, pending) {
+  let nextRequest = 1;
+  return {
+    fetch(request) {
+      const requestId = `${Date.now()}_${nextRequest++}`;
+      post({
+        channel: "slexkit-secure",
+        type: "fetch",
+        id,
+        token,
+        requestId,
+        request
+      });
+      return new Promise((resolve, reject) => {
+        pending.set(requestId, { resolve, reject });
+      });
+    },
+    setTimeout(fn, ms) {
+      if (!schedulingSnapshot.setTimeout) {
+        throw new SlexKitRuntimeError("policy", "timer_unavailable", "Native timer host is unavailable.");
+      }
+      return schedulingSnapshot.setTimeout(fn, ms);
+    },
+    clearTimeout(id2) {
+      schedulingSnapshot.clearTimeout?.(id2);
+    },
+    setInterval(fn, ms) {
+      if (!schedulingSnapshot.setInterval) {
+        throw new SlexKitRuntimeError("policy", "timer_unavailable", "Native interval host is unavailable.");
+      }
+      return schedulingSnapshot.setInterval(fn, ms);
+    },
+    clearInterval(id2) {
+      schedulingSnapshot.clearInterval?.(id2);
+    },
+    requestAnimationFrame(fn) {
+      if (!schedulingSnapshot.requestAnimationFrame) {
+        throw new SlexKitRuntimeError("policy", "animation_unavailable", "Native animation frame host is unavailable.");
+      }
+      return schedulingSnapshot.requestAnimationFrame(fn);
+    },
+    cancelAnimationFrame(id2) {
+      schedulingSnapshot.cancelAnimationFrame?.(id2);
+    }
+  };
+}
+function blockedNetworkError() {
+  return new Error("Native network APIs are disabled inside the SlexKit sandbox. Use api.get(), api.post(), or api.fetch().");
+}
+function defineBlockedGlobal(name, value) {
+  try {
+    Object.defineProperty(globalThis, name, {
+      configurable: true,
+      value
+    });
+  } catch {}
+}
+function hardenNetworkGlobals() {
+  defineBlockedGlobal("fetch", () => Promise.reject(blockedNetworkError()));
+  defineBlockedGlobal("XMLHttpRequest", class {
+    constructor() {
+      throw blockedNetworkError();
+    }
+  });
+  defineBlockedGlobal("WebSocket", class {
+    constructor() {
+      throw blockedNetworkError();
+    }
+  });
+  defineBlockedGlobal("EventSource", class {
+    constructor() {
+      throw blockedNetworkError();
+    }
+  });
+  defineBlockedGlobal("Worker", class {
+    constructor() {
+      throw blockedNetworkError();
+    }
+  });
+  defineBlockedGlobal("SharedWorker", class {
+    constructor() {
+      throw blockedNetworkError();
+    }
+  });
+  try {
+    Object.defineProperty(navigator, "sendBeacon", {
+      configurable: true,
+      value: () => false
+    });
+  } catch {}
+}
+function blockedSchedulingError(name) {
+  return new SlexKitRuntimeError("policy", "native_scheduling_disabled", `Native ${name} is disabled inside the SlexKit sandbox. Use api.${name}().`);
+}
+function hardenSchedulingGlobals() {
+  defineBlockedGlobal("setTimeout", () => {
+    throw blockedSchedulingError("setTimeout");
+  });
+  defineBlockedGlobal("setInterval", () => {
+    throw blockedSchedulingError("setInterval");
+  });
+  defineBlockedGlobal("requestAnimationFrame", () => {
+    throw blockedSchedulingError("raf");
+  });
+  defineBlockedGlobal("clearTimeout", () => {
+    return;
+  });
+  defineBlockedGlobal("clearInterval", () => {
+    return;
+  });
+  defineBlockedGlobal("cancelAnimationFrame", () => {
+    return;
+  });
+}
+var canvasSnapshot = {
+  getContext: typeof HTMLCanvasElement !== "undefined" ? HTMLCanvasElement.prototype.getContext : undefined,
+  offscreenCanvas: typeof OffscreenCanvas !== "undefined" ? OffscreenCanvas : undefined
+};
+function canvasPolicyError(code, message) {
+  return new SlexKitRuntimeError("policy", code, message);
+}
+function assertSandboxCanvasPolicy(policy, width, height, contextId) {
+  if (!policy.enabled) {
+    throw canvasPolicyError("canvas_disabled", "Canvas access is disabled.");
+  }
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+    throw canvasPolicyError("canvas_size_invalid", "Canvas size must be positive finite numbers.");
+  }
+  const pixels = Math.ceil(width) * Math.ceil(height);
+  if (policy.maxPixels !== undefined && pixels > policy.maxPixels) {
+    throw canvasPolicyError("canvas_too_large", "Canvas size exceeds the runtime policy limit.");
+  }
+  if (contextId && policy.allowedContexts?.length && !policy.allowedContexts.includes(contextId)) {
+    throw canvasPolicyError("canvas_context_blocked", `Canvas context ${contextId} is not allowed.`);
+  }
+}
+function hardenCanvasGlobals(policy) {
+  if (typeof HTMLCanvasElement !== "undefined" && canvasSnapshot.getContext) {
+    const contextCanvases = new WeakSet;
+    let contextCanvasCount = 0;
+    const canvasPolicy2 = policy.canvas;
+    HTMLCanvasElement.prototype.getContext = function getContext(contextId, options) {
+      if (!canvasPolicy2?.enabled) {
+        throw canvasPolicyError("canvas_disabled", "Canvas access is disabled.");
+      }
+      assertSandboxCanvasPolicy(canvasPolicy2, this.width, this.height, contextId);
+      if (!contextCanvases.has(this)) {
+        if (canvasPolicy2.maxCanvases !== undefined && contextCanvasCount >= canvasPolicy2.maxCanvases) {
+          throw canvasPolicyError("canvas_limit", "Canvas limit exceeded.");
+        }
+        contextCanvases.add(this);
+        contextCanvasCount += 1;
+      }
+      return canvasSnapshot.getContext.call(this, contextId, options);
+    };
+  }
+  if (canvasSnapshot.offscreenCanvas) {
+    const OriginalOffscreenCanvas = canvasSnapshot.offscreenCanvas;
+    defineBlockedGlobal("OffscreenCanvas", class extends OriginalOffscreenCanvas {
+      constructor(width, height) {
+        const canvasPolicy2 = policy.canvas;
+        if (!canvasPolicy2?.enabled) {
+          throw canvasPolicyError("canvas_disabled", "Canvas access is disabled.");
+        }
+        assertSandboxCanvasPolicy(canvasPolicy2, width, height);
+        super(width, height);
+      }
+    });
+  }
+}
+function startSlexKitSandboxRunner() {
+  hardenNetworkGlobals();
+  hardenSchedulingGlobals();
+  const pendingFetches = new Map;
+  let cleanup;
+  let runtimeDispose;
+  let activeId;
+  let activeToken;
+  let heartbeatTimer;
+  let slotResizeObserver;
+  function clearHeartbeat() {
+    if (heartbeatTimer === undefined)
+      return;
+    schedulingSnapshot.clearInterval?.(heartbeatTimer);
+    heartbeatTimer = undefined;
+  }
+  function startHeartbeat(policy, id, token) {
+    clearHeartbeat();
+    const intervalMs = Math.max(100, policy.execution?.heartbeatIntervalMs ?? 1000);
+    if (!schedulingSnapshot.setInterval)
+      return;
+    heartbeatTimer = schedulingSnapshot.setInterval(() => {
+      post({
+        channel: "slexkit-secure",
+        type: "heartbeat",
+        id,
+        token
+      });
+    }, intervalMs);
+  }
+  function dispose(id) {
+    if (id && activeId && id !== activeId)
+      return;
+    clearHeartbeat();
+    slotResizeObserver?.disconnect();
+    slotResizeObserver = undefined;
+    cleanup?.();
+    runtimeDispose?.();
+    for (const pending of pendingFetches.values()) {
+      pending.reject(new Error("SlexKit sandbox runtime was disposed."));
+    }
+    pendingFetches.clear();
+    cleanup = undefined;
+    runtimeDispose = undefined;
+    activeId = undefined;
+    activeToken = undefined;
+    const root = frameRoot();
+    root.style.removeProperty("position");
+    root.style.removeProperty("min-height");
+    root.replaceChildren();
+  }
+  function slotElement(slotId) {
+    return document.getElementById(`slexkit-slot-${slotId}`);
+  }
+  function reportSlotSize(slotId, element) {
+    if (!activeId || !activeToken)
+      return;
+    const height = Math.max(element.scrollHeight, element.getBoundingClientRect().height);
+    post({
+      channel: "slexkit-secure",
+      type: "slot-size",
+      id: activeId,
+      token: activeToken,
+      slotId,
+      height
+    });
+  }
+  function applySlotRects(slots) {
+    const root = frameRoot();
+    const multiSlot = slots.length > 1;
+    if (multiSlot) {
+      const maxBottom = Math.max(1, ...slots.map((slot) => slot.top + slot.height));
+      root.style.position = "relative";
+      root.style.minHeight = `${Math.ceil(maxBottom)}px`;
+    } else {
+      root.style.removeProperty("position");
+      root.style.removeProperty("min-height");
+    }
+    slotResizeObserver?.disconnect();
+    slotResizeObserver = typeof ResizeObserver !== "undefined" ? new ResizeObserver((entries) => {
+      for (const entry of entries) {
+        const element = entry.target;
+        const slotId = element.dataset.slexkitSlotId;
+        if (slotId)
+          reportSlotSize(slotId, element);
+      }
+    }) : undefined;
+    for (const slot of slots) {
+      const element = slotElement(slot.id);
+      if (!element)
+        continue;
+      element.dataset.slexkitSlotId = slot.id;
+      element.style.boxSizing = "border-box";
+      if (multiSlot) {
+        element.style.position = "absolute";
+        element.style.left = `${slot.left}px`;
+        element.style.top = `${slot.top}px`;
+      } else {
+        element.style.removeProperty("position");
+        element.style.removeProperty("left");
+        element.style.removeProperty("top");
+      }
+      if (slot.width > 0)
+        element.style.width = `${slot.width}px`;
+      slotResizeObserver?.observe(element);
+      reportSlotSize(slot.id, element);
+    }
+  }
+  async function mountArtifact(message) {
+    dispose();
+    activeId = message.id;
+    activeToken = message.token;
+    hardenCanvasGlobals(message.policy);
+    applyColorMode(message.colorMode);
+    const runtime = createSecureRuntime(message.policy, createBridgeAdapter(message.id, message.token, pendingFetches));
+    runtimeDispose = runtime.dispose;
+    cleanup = mount(message.input, frameRoot(), {
+      theme: message.theme,
+      dir: message.dir,
+      labels: message.labels,
+      api: runtime.api
+    });
+    startHeartbeat(message.policy, message.id, message.token);
+    post({
+      channel: "slexkit-secure",
+      type: "mounted",
+      id: message.id,
+      token: message.token
+    });
+  }
+  window.addEventListener("message", (event) => {
+    if (event.source !== window.parent || !isHostMessage(event.data))
+      return;
+    const message = event.data;
+    try {
+      if (message.type === "mount") {
+        mountArtifact(message).catch((error) => {
+          post({
+            channel: "slexkit-secure",
+            type: "error",
+            id: message.id,
+            token: message.token,
+            error: serializeRuntimeError(error)
+          });
+        });
+      } else if (message.type === "dispose") {
+        if (activeToken && message.token !== activeToken)
+          return;
+        dispose(message.id);
+        post({
+          channel: "slexkit-secure",
+          type: "disposed",
+          id: message.id,
+          token: message.token
+        });
+      } else if (message.type === "fetch-result") {
+        const response = message;
+        if (activeToken && response.token !== activeToken)
+          return;
+        const pending = pendingFetches.get(response.requestId);
+        if (!pending)
+          return;
+        pendingFetches.delete(response.requestId);
+        if (response.error)
+          pending.reject(deserializeRuntimeError(response.error));
+        else
+          pending.resolve(response.result);
+      } else if (message.type === "slots") {
+        if (activeToken && message.token !== activeToken)
+          return;
+        applySlotRects(message.slots);
+      }
+    } catch (error) {
+      post({
+        channel: "slexkit-secure",
+        type: "error",
+        id: "id" in message ? message.id : undefined,
+        token: activeToken,
+        error: serializeRuntimeError(error)
+      });
+    }
+  });
+  post({
+    channel: "slexkit-secure",
+    type: "ready"
+  });
+}
+
+// src/runtime.ts
+setSlexKitRuntimeUrl(import.meta.url);
+var mountApi = mount;
+var ingestApi = ingest;
+var bootApi = boot;
+var disposeNamespaceApi = disposeNamespace;
+var registerApi = register;
+var getRendererApi = getRenderer;
+var diagnoseSlexKitSourceApi = diagnoseSlexKitSource;
+var SlexKitSyntaxErrorApi = SlexKitSyntaxError;
+var formatSlexKitDiagnosticApi = formatSlexKitDiagnostic;
+var mountSecureArtifactApi = mountSecureArtifact;
+var parseSlexSourceApi = parseSlexSource;
+var parseSlexKitDslApi = parseSlexKitDsl;
+var createSecureRuntimeApi = createSecureRuntime;
+var SlexKitRuntimeErrorApi = SlexKitRuntimeError;
+var getSlexKitRuntimeUrlApi = getSlexKitRuntimeUrl;
+var setSlexKitRuntimeUrlApi = setSlexKitRuntimeUrl;
+var createSlexKitMarkdownRuntimeHostApi = createSlexKitMarkdownRuntimeHost;
+var getSlexKitMarkdownRuntimeHostApi = getSlexKitMarkdownRuntimeHost;
+var installSlexKitMarkdownRuntimeHostApi = installSlexKitMarkdownRuntimeHost;
+var attachComponentDisposerApi = attachComponentDisposer;
+var configureComponentScopeApi = configureComponentScope;
+var startSlexKitSandboxRunnerApi = startSlexKitSandboxRunner;
+var getSlexKitInfoApi = getSlexKitInfo;
+export {
+  startSlexKitSandboxRunnerApi as startSlexKitSandboxRunner,
+  setSlexKitRuntimeUrlApi as setSlexKitRuntimeUrl,
+  registerApi as register,
+  parseSlexSourceApi as parseSlexSource,
+  parseSlexKitDslApi as parseSlexKitDsl,
+  mountSecureArtifactApi as mountSecureArtifact,
+  mountApi as mount,
+  installSlexKitMarkdownRuntimeHostApi as installSlexKitMarkdownRuntimeHost,
+  ingestApi as ingest,
+  getSlexKitRuntimeUrlApi as getSlexKitRuntimeUrl,
+  getSlexKitMarkdownRuntimeHostApi as getSlexKitMarkdownRuntimeHost,
+  getSlexKitInfoApi as getSlexKitInfo,
+  getRendererApi as getRenderer,
+  formatSlexKitDiagnosticApi as formatSlexKitDiagnostic,
+  disposeNamespaceApi as disposeNamespace,
+  diagnoseSlexKitSourceApi as diagnoseSlexKitSource,
+  createSlexKitMarkdownRuntimeHostApi as createSlexKitMarkdownRuntimeHost,
+  createSecureRuntimeApi as createSecureRuntime,
+  configureComponentScopeApi as configureComponentScope,
+  bootApi as boot,
+  attachComponentDisposerApi as attachComponentDisposer,
+  SlexKitSyntaxErrorApi as SlexKitSyntaxError,
+  SlexKitRuntimeErrorApi as SlexKitRuntimeError,
+  SLEX_PROTOCOL_VERSION,
+  SLEXKIT_VERSION,
+  SLEXKIT_COMPONENTS_VERSION
+};