@ai-matrx/content-ir-react 0.1.0

package/dist/index.cjs

@@ -0,0 +1,769 @@
+'use strict';
+
+var React = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var contentIr = require('@ai-matrx/content-ir');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+// host/error-report.ts
+var consoleErrorReporter = (report) => {
+  console.error(`[content-ir] ${report.message}`, report.raw ?? "");
+};
+
+// host/host-types.ts
+function routeEnvOf(host) {
+  return {
+    kinds: host.kinds,
+    components: host.components,
+    reportError: host.reportError,
+    platform: host.platform
+  };
+}
+var ContentIrHostContext = React.createContext(null);
+function ContentIrRenderProvider({
+  host,
+  children
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(ContentIrHostContext.Provider, { value: host, children });
+}
+function useContentIrHostOrNull() {
+  return React.useContext(ContentIrHostContext);
+}
+function useContentIrHost() {
+  const host = useContentIrHostOrNull();
+  if (!host) {
+    throw new Error(
+      "[content-ir-react] No ContentIrRenderProvider above this component. Mount one at the app root with your host adapter (kind definitions, component resolver, renderBlock, renderValue, reportError)."
+    );
+  }
+  return host;
+}
+function useKindRouteEnv() {
+  const host = useContentIrHost();
+  return React.useMemo(() => routeEnvOf(host), [host]);
+}
+
+// resolver/component-resolver.ts
+var KEY_SEPARATOR = String.fromCharCode(1);
+function keyOf(kind, platform, role) {
+  return `${kind}${KEY_SEPARATOR}${platform}${KEY_SEPARATOR}${role}`;
+}
+function describe(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function errorFields(error) {
+  if (!(error instanceof Error)) return {};
+  return {
+    name: error.name,
+    ...error.stack === void 0 ? {} : { stack: error.stack }
+  };
+}
+var ComponentResolver = class {
+  compiled = null;
+  db = /* @__PURE__ */ new Map();
+  warmPromise = null;
+  warmFailureLogged = false;
+  /**
+   * When the last successful wholesale refresh landed, or null for "never".
+   * Explicitly nullable rather than 0: with a host-supplied clock that starts
+   * near zero, a `0` sentinel makes the FIRST refresh look rate-limited and
+   * silently skip.
+   */
+  lastRefreshAt = null;
+  refreshPromise = null;
+  listeners = /* @__PURE__ */ new Set();
+  /**
+   * Cold single-kind fetch dedupe (streaming eager path). In-flight is keyed
+   * by (kind, platform) — the fetch unit; misses are keyed by (kind, platform,
+   * role) so a miss on web/output never suppresses other roles, and CLEARED on
+   * every wholesale refresh (a component created mid-session becomes eagerly
+   * fetchable again — misses are cheap to re-verify).
+   */
+  coldInFlight = /* @__PURE__ */ new Set();
+  coldMisses = /* @__PURE__ */ new Set();
+  /** Monotonic db-tier version — the repaint hook's snapshot key. */
+  version = 0;
+  /** Per-kind versions + listeners (granular repaint) + wholesale epoch. */
+  kindVersions = /* @__PURE__ */ new Map();
+  kindListeners = /* @__PURE__ */ new Map();
+  epoch = 0;
+  reportError;
+  now;
+  options;
+  // Explicit field, not a parameter property: consumers compile this source
+  // directly, and a strict host (the dashboard) sets `erasableSyntaxOnly`,
+  // under which parameter properties are a hard error.
+  constructor(options = {}) {
+    this.options = options;
+    this.reportError = options.reportError ?? consoleErrorReporter;
+    this.now = options.now ?? (() => Date.now());
+  }
+  compiledMap() {
+    if (!this.compiled) {
+      this.compiled = /* @__PURE__ */ new Map();
+      for (const entry of this.options.compiledEntries?.() ?? []) {
+        this.compiled.set(keyOf(entry.kind, entry.platform, entry.role), entry);
+      }
+    }
+    return this.compiled;
+  }
+  /**
+   * Synchronous resolve — the render seam's per-block call. DB override first
+   * (once warm), compiled floor second, null for unknown.
+   */
+  resolve(kind, platform, role) {
+    const key = keyOf(kind, platform, role);
+    const dbRow = this.db.get(key);
+    if (dbRow) {
+      return {
+        componentKey: dbRow.componentKey,
+        source: dbRow.source,
+        config: dbRow.config,
+        isActive: dbRow.isActive,
+        resolvedBy: "db",
+        componentSource: dbRow.componentSource,
+        propsTransform: dbRow.propsTransform,
+        pinnedKindVersion: dbRow.pinnedKindVersion,
+        updatedAt: dbRow.updatedAt,
+        createdBy: dbRow.createdBy
+      };
+    }
+    const compiledEntry = this.compiledMap().get(key);
+    if (compiledEntry) {
+      return {
+        componentKey: compiledEntry.componentKey,
+        source: compiledEntry.source,
+        config: compiledEntry.config,
+        isActive: true,
+        // trusted at bootstrap (R6)
+        resolvedBy: "compiled",
+        componentSource: null,
+        propsTransform: null,
+        pinnedKindVersion: null,
+        updatedAt: null,
+        createdBy: null
+      };
+    }
+    return null;
+  }
+  /** R6 floor check: compiled-bootstrap membership = always render-trusted. */
+  hasCompiled(kind, platform, role) {
+    return this.compiledMap().has(keyOf(kind, platform, role));
+  }
+  /**
+   * Pure ingest — the warm landing point and the unit-test seam. First row per
+   * key wins: rows arrive is_default-first / sort_order-asc from the source.
+   */
+  ingestDbRows(rows) {
+    const changedKinds = /* @__PURE__ */ new Set();
+    for (const row of rows) {
+      const key = keyOf(row.kind, row.platform, row.role);
+      if (!this.db.has(key)) {
+        this.db.set(key, row);
+        changedKinds.add(row.kind);
+      }
+    }
+    if (changedKinds.size > 0) {
+      for (const kind of changedKinds) this.bumpKind(kind);
+      this.notifyChanged();
+    }
+  }
+  /**
+   * Refresh landing point: REPLACE the db tier wholesale (same
+   * first-row-per-key contract as {@link ingestDbRows}) so edits, deletions,
+   * and is_active flips all take effect. Always notifies.
+   */
+  replaceDbRows(rows) {
+    this.db.clear();
+    this.coldMisses.clear();
+    for (const row of rows) {
+      const key = keyOf(row.kind, row.platform, row.role);
+      if (!this.db.has(key)) this.db.set(key, row);
+    }
+    this.epoch += 1;
+    for (const set of this.kindListeners.values()) {
+      for (const listener of set) listener();
+    }
+    this.notifyChanged();
+  }
+  getVersion() {
+    return this.version;
+  }
+  getKindVersion(kind) {
+    return this.epoch + (this.kindVersions.get(kind) ?? 0);
+  }
+  subscribeKind(kind, listener) {
+    const set = this.kindListeners.get(kind) ?? /* @__PURE__ */ new Set();
+    set.add(listener);
+    this.kindListeners.set(kind, set);
+    return () => {
+      set.delete(listener);
+      if (set.size === 0) this.kindListeners.delete(kind);
+    };
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  bumpKind(kind) {
+    this.kindVersions.set(kind, (this.kindVersions.get(kind) ?? 0) + 1);
+    const listeners = this.kindListeners.get(kind);
+    if (listeners) for (const listener of listeners) listener();
+  }
+  notifyChanged() {
+    this.version += 1;
+    for (const listener of this.listeners) listener();
+  }
+  /**
+   * The eager lightweight single-kind fetch (streaming path): the moment a
+   * cloud kind is identified mid-stream, pull ONLY that kind's resolver rows
+   * and ingest them so {@link resolve} can answer before — or shortly after —
+   * the region completes. Deduped in-flight and by known-miss. Fire-and-forget;
+   * failures are loud (the warm list remains the backstop).
+   */
+  requestComponent(kind, platform, role) {
+    const loadForKind = this.options.loadForKind;
+    if (!loadForKind) return;
+    if (this.resolve(kind, platform, role)) return;
+    const missKey = keyOf(kind, platform, role);
+    const flightKey = `${kind}${KEY_SEPARATOR}${platform}`;
+    if (this.coldInFlight.has(flightKey) || this.coldMisses.has(missKey)) {
+      return;
+    }
+    this.coldInFlight.add(flightKey);
+    void (async () => {
+      try {
+        this.ingestDbRows(await loadForKind(kind, platform));
+        if (!this.resolve(kind, platform, role)) this.coldMisses.add(missKey);
+      } catch (error) {
+        this.reportError({
+          source: "content-ir",
+          message: `component-resolver cold fetch failed for "${kind}": ${describe(error)}`,
+          ...errorFields(error),
+          raw: error
+        });
+      } finally {
+        this.coldInFlight.delete(flightKey);
+      }
+    })();
+  }
+  /**
+   * Refresh-on-view: re-fetch the warm list and REPLACE the db tier, so an
+   * edited `source='db'` component (its `updated_at` bump re-keys the host's
+   * compile cache) renders fresh on the next view. Deduped in-flight and
+   * rate-limited by `maxAgeMs` (default 10s) — mounting several previews costs
+   * one fetch. Server-side edits do NOT push to open clients; the contract is
+   * refresh-on-view via this call.
+   */
+  refresh(maxAgeMs = 1e4) {
+    const loadAll = this.options.loadAll;
+    if (!loadAll) return Promise.resolve();
+    if (this.refreshPromise) return this.refreshPromise;
+    if (this.lastRefreshAt !== null && this.now() - this.lastRefreshAt < maxAgeMs) {
+      return Promise.resolve();
+    }
+    this.coldMisses.clear();
+    this.refreshPromise = loadAll().then((rows) => {
+      this.lastRefreshAt = this.now();
+      this.replaceDbRows(rows);
+    }).catch((error) => {
+      this.reportError({
+        source: "content-ir",
+        message: `component-resolver refresh failed (current resolver tier still serving): ${describe(error)}`,
+        ...errorFields(error),
+        raw: error
+      });
+    }).finally(() => {
+      this.refreshPromise = null;
+    });
+    return this.refreshPromise;
+  }
+  /** One list fetch per app session; failed loads retry on the next call. */
+  ensureWarm() {
+    const loadAll = this.options.loadAll;
+    if (!loadAll) return Promise.resolve();
+    if (!this.warmPromise) {
+      this.warmPromise = loadAll().then((rows) => {
+        this.ingestDbRows(rows);
+      }).catch((error) => {
+        const message = `component-resolver warm load failed (compiled bootstrap still serving): ${describe(error)}`;
+        if (!this.warmFailureLogged) {
+          this.warmFailureLogged = true;
+          console.error(`[content-ir] ${message}`);
+        }
+        this.reportError({
+          source: "content-ir",
+          message,
+          ...errorFields(error),
+          raw: error
+        });
+        this.warmPromise = null;
+      });
+    }
+    return this.warmPromise;
+  }
+};
+var IR_ROUTE_KEY = "__ir_route";
+var GENERIC_STRUCTURED_COMPONENT_KEY = "generic_structured";
+var DB_KIND_COMPONENT_KEY = "db_kind_component";
+function isDbSourceResolution(resolution) {
+  return resolution !== null && resolution.resolvedBy === "db" && resolution.source === "db" && resolution.isActive;
+}
+var reportedSourcelessDbRows = /* @__PURE__ */ new Set();
+function reportDbRowWithoutSource(kind, env) {
+  const message = `[content-ir] kind_component for "${kind}" declares source='db' + is_active but has NO component_source \u2014 data defect; falling through to bundled rendering.`;
+  if (!reportedSourcelessDbRows.has(kind)) {
+    reportedSourcelessDbRows.add(kind);
+    console.error(message);
+  }
+  env.reportError({ source: "content-ir", message, raw: { kind } });
+}
+function resetSourcelessDbRowReports() {
+  reportedSourcelessDbRows.clear();
+}
+function routeToDbComponent(block, kind, resolution, env) {
+  if (!isDbSourceResolution(resolution)) return null;
+  if (!resolution.componentSource || !resolution.componentSource.trim()) {
+    reportDbRowWithoutSource(kind, env);
+    return null;
+  }
+  if (block.type === DB_KIND_COMPONENT_KEY) return block;
+  return {
+    ...block,
+    type: DB_KIND_COMPONENT_KEY,
+    // The compiled/sandboxed component reads the envelope, never the raw
+    // region's annotation serverData (same poison rule as bridged kinds).
+    serverData: void 0,
+    metadata: withRouteMarker(block.metadata, resolution)
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRouteMarker(value) {
+  return isRecord(value) && typeof value.by === "string" && typeof value.key === "string";
+}
+function readIrRouteMarker(metadata) {
+  const candidate = metadata?.[IR_ROUTE_KEY];
+  return isRouteMarker(candidate) ? candidate : null;
+}
+function withRouteMarker(metadata, resolution) {
+  return {
+    ...metadata,
+    [IR_ROUTE_KEY]: {
+      by: resolution.resolvedBy,
+      key: resolution.componentKey
+    }
+  };
+}
+function routeToGeneric(block, reason) {
+  if (block.type === GENERIC_STRUCTURED_COMPONENT_KEY) return block;
+  return {
+    ...block,
+    type: GENERIC_STRUCTURED_COMPONENT_KEY,
+    serverData: void 0,
+    metadata: {
+      ...block.metadata,
+      [IR_ROUTE_KEY]: {
+        by: "generic",
+        key: GENERIC_STRUCTURED_COMPONENT_KEY,
+        unverified: true,
+        reason
+      }
+    }
+  };
+}
+function applyIrKindRoute(block, env, options) {
+  if (options?.ownedTypes?.includes(block.type)) return block;
+  const envelope = contentIr.readEnvelope(block.metadata);
+  if (!envelope) return block;
+  const kind = envelope.root.kind;
+  if (!kind) return block;
+  if (envelope.root.kindState === "pending_schema") return block;
+  const def = env.kinds.getDefinition(kind);
+  const resolution = env.components.resolve(kind, env.platform, "output");
+  const dbRouted = routeToDbComponent(block, kind, resolution, env);
+  if (dbRouted) return dbRouted;
+  if (def?.legacyBlockType) {
+    if (block.type === def.legacyBlockType && block.serverData) return block;
+    const serverData = def.toLegacyServerData?.(envelope);
+    if (block.type === def.legacyBlockType && serverData === void 0) {
+      return block;
+    }
+    return {
+      ...block,
+      type: def.legacyBlockType,
+      serverData,
+      ...resolution ? { metadata: withRouteMarker(block.metadata, resolution) } : null
+    };
+  }
+  if (resolution?.isActive) {
+    if (block.type === resolution.componentKey) return block;
+    return {
+      ...block,
+      type: resolution.componentKey,
+      // No compiled bridge exists — the routed component parses `content`
+      // itself; the raw region's annotation serverData is CLEARED.
+      serverData: void 0,
+      metadata: withRouteMarker(block.metadata, resolution)
+    };
+  }
+  if (def) {
+    return routeToGeneric(block, resolution ? "inactive" : "no-component");
+  }
+  return block;
+}
+function kindServerDataFromStoredValue(value, env) {
+  if (!isRecord(value)) return null;
+  const kind = contentIr.readObjectKind(value);
+  if (!kind) return null;
+  const def = env.kinds.getDefinition(kind);
+  if (!def?.toLegacyServerData) return null;
+  return def.toLegacyServerData(contentIr.envelopeFromCompleteValue(value, kind)) ?? null;
+}
+var IR_PROVISIONAL_KEY = "__ir_provisional";
+function isProvisionalBlock(metadata) {
+  return metadata?.[IR_PROVISIONAL_KEY] === true;
+}
+function envelopeFromPartialKind(event) {
+  return {
+    v: contentIr.IR_VERSION,
+    // The partial channel is only ever produced by the Python detector; the
+    // envelope's `engine` union has no third member and inventing one would
+    // break every existing reader.
+    engine: "py-block-detector",
+    fingerprint: event.fingerprint,
+    root: event.root
+  };
+}
+var partialUnsafeKinds = /* @__PURE__ */ new Set();
+function markKindPartialUnsafe(kind) {
+  partialUnsafeKinds.add(kind);
+}
+function resetPartialUnsafeKinds() {
+  partialUnsafeKinds.clear();
+}
+function isPartialReadyKind(kind, env) {
+  if (!kind || partialUnsafeKinds.has(kind)) return false;
+  return env.kinds.getDefinition(kind)?.partialReady === true;
+}
+function resolveAnnouncedKindLoading(block, options) {
+  if (options?.streamActive === false) return null;
+  const event = contentIr.readPartialKindEvent(block.metadata);
+  if (!contentIr.isProvisionalKind(event)) return null;
+  const kind = event.root.kind;
+  if (!kind) return null;
+  const verified = contentIr.readEnvelope(block.metadata);
+  if (verified && verified.root.status === "complete") return null;
+  return { kind, envelope: envelopeFromPartialKind(event) };
+}
+function resolveProvisionalKindRender(block, env, options) {
+  if (options?.streamActive === false) return null;
+  const event = contentIr.readPartialKindEvent(block.metadata);
+  if (!contentIr.isProvisionalKind(event)) return null;
+  const kind = event.root.kind;
+  if (!isPartialReadyKind(kind, env)) return null;
+  const verified = contentIr.readEnvelope(block.metadata);
+  if (verified && verified.root.status === "complete") return null;
+  const { [contentIr.IR_PARTIAL_KEY]: _partial, ...rest } = block.metadata ?? {};
+  const envelope = envelopeFromPartialKind(event);
+  const provisionalBlock = {
+    ...block,
+    // The raw region annotation (`{ language: "json" }`) is not kind data —
+    // same poison rule the verified route follows.
+    serverData: void 0,
+    metadata: {
+      ...rest,
+      [contentIr.IR_ENVELOPE_KEY]: envelope,
+      [IR_PROVISIONAL_KEY]: true
+    }
+  };
+  const routed = applyIrKindRoute(provisionalBlock, env, options);
+  if (routed === provisionalBlock) return null;
+  if (env.kinds.getDefinition(kind)?.toLegacyServerData && !routed.serverData) {
+    return null;
+  }
+  return { block: routed, kind, seq: event.seq, envelope };
+}
+var noopSubscribe = () => () => {
+};
+var zero = () => 0;
+function useContentIrKindVersion(kind, sources) {
+  const host = useContentIrHostOrNull();
+  const resolved = sources ?? host;
+  if (kind && !resolved) {
+    throw new Error(
+      "[content-ir-react] useContentIrKindVersion needs either a ContentIrRenderProvider above it or explicit `sources`."
+    );
+  }
+  const subscribe = React.useCallback(
+    (onStoreChange) => {
+      if (!kind || !resolved) return noopSubscribe();
+      const unsubKinds = resolved.kinds.subscribeKind(kind, onStoreChange);
+      const unsubComponents = resolved.components.subscribeKind(
+        kind,
+        onStoreChange
+      );
+      return () => {
+        unsubKinds();
+        unsubComponents();
+      };
+    },
+    [resolved, kind]
+  );
+  const getSnapshot = React.useCallback(
+    () => kind && resolved ? (
+      // Both counters are monotonic, so the sum is monotonic — a change in
+      // either registry produces a new snapshot value for this kind.
+      resolved.kinds.getKindVersion(kind) + resolved.components.getKindVersion(kind)
+    ) : 0,
+    [resolved, kind]
+  );
+  return React.useSyncExternalStore(subscribe, getSnapshot, zero);
+}
+function isRecordValue(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function kindIsRoutable(kind, host) {
+  if (host.kinds.getDefinition(kind)?.legacyBlockType) return true;
+  return Boolean(
+    host.components.resolve(kind, host.platform, "output")?.isActive
+  );
+}
+function KindInstanceRender({
+  kind,
+  value,
+  showRoutingNote = true,
+  unroutableFallback,
+  variant = "card",
+  className
+}) {
+  const host = useContentIrHost();
+  const [routingStatus, setRoutingStatus] = React.useState(
+    () => kindIsRoutable(kind, host) ? "routable" : "checking"
+  );
+  React.useEffect(() => {
+    let cancelled = false;
+    let warmed = false;
+    const syncRoutingStatus = () => {
+      if (cancelled) return;
+      setRoutingStatus(
+        kindIsRoutable(kind, host) ? "routable" : warmed ? "unroutable" : "checking"
+      );
+    };
+    const unsubscribe = host.components.subscribe(syncRoutingStatus);
+    syncRoutingStatus();
+    host.components.requestComponent(kind, host.platform, "output");
+    const wasAlreadyWarm = host.components.getVersion() > 0;
+    void Promise.allSettled([
+      host.kinds.ensureWarm(),
+      host.components.ensureWarm()
+    ]).then(async () => {
+      warmed = true;
+      syncRoutingStatus();
+      if (wasAlreadyWarm) await host.components.refresh();
+      syncRoutingStatus();
+    });
+    return () => {
+      cancelled = true;
+      unsubscribe();
+    };
+  }, [host, kind]);
+  const block = isRecordValue(value) ? {
+    type: "code",
+    content: JSON.stringify(value, null, 2),
+    language: "json",
+    metadata: {
+      [contentIr.IR_ENVELOPE_KEY]: contentIr.envelopeFromCompleteValue(value, kind)
+    }
+  } : null;
+  const frameClass = variant === "bare" ? void 0 : "rounded-md border border-border bg-card p-3";
+  if (routingStatus === "unroutable" && unroutableFallback !== void 0) {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: unroutableFallback });
+  }
+  const onTheFloor = block === null || routingStatus === "unroutable";
+  const notice = "This shape has no custom component yet, so it renders through the universal viewer \u2014 exactly what production shows today.";
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: className ? `space-y-3 ${className}` : "space-y-3", children: [
+    showRoutingNote && routingStatus === "unroutable" ? host.renderNotice?.(notice) ?? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "rounded-md border border-amber-500/30 bg-amber-500/5 px-3 py-2 text-xs text-amber-800 dark:text-amber-200", children: notice }) : null,
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: frameClass, children: onTheFloor ? host.renderValue({ value, kind }) : host.renderBlock(block) })
+  ] });
+}
+var ProvisionalKindBoundaryInner = class extends React__default.default.Component {
+  state = { failed: false };
+  static getDerivedStateFromError() {
+    return { failed: true };
+  }
+  componentDidCatch(error, info) {
+    const { kind, reportError } = this.props;
+    markKindPartialUnsafe(kind);
+    reportError({
+      source: "content-ir",
+      message: `kind "${kind}" declares partialReady but its component threw on a provisional value \u2014 provisional rendering disabled for this kind (falling back to its loading skeleton). Fix the component or drop partialReady.`,
+      name: error.name,
+      ...error.stack === void 0 ? {} : { stack: error.stack },
+      relation: "partial-kind",
+      raw: { kind, componentStack: info.componentStack }
+    });
+  }
+  render() {
+    if (this.state.failed) return this.props.fallback;
+    return this.props.children;
+  }
+};
+function ProvisionalKindBoundary(props) {
+  const host = useContentIrHost();
+  return /* @__PURE__ */ jsxRuntime.jsx(ProvisionalKindBoundaryInner, { ...props, reportError: host.reportError });
+}
+function ProvisionalKindFrame({ children }) {
+  const host = useContentIrHost();
+  const label = "Still arriving";
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative", "aria-busy": "true", children: [
+    children,
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "pointer-events-none absolute -top-2 right-4 z-10 select-none rounded-full bg-background px-1.5 leading-4", children: host.renderShimmer?.(label) ?? /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-[10px] text-muted-foreground", children: label }) })
+  ] });
+}
+function readStructuredValue(content, metadata) {
+  const envelope = contentIr.readEnvelope(metadata);
+  if (envelope) {
+    return { value: contentIr.reconstructRegionValue(envelope), recovered: true };
+  }
+  try {
+    return { value: JSON.parse(content), recovered: true };
+  } catch {
+    return { value: null, recovered: false };
+  }
+}
+function GenericStructuredView({
+  content,
+  metadata,
+  streamingIndicator,
+  className
+}) {
+  const host = useContentIrHost();
+  const envelope = contentIr.readEnvelope(metadata);
+  const status = envelope?.root.status ?? "complete";
+  const { value, recovered } = readStructuredValue(content, metadata);
+  const kind = envelope?.root.kind ?? (typeof value === "object" && value !== null && !Array.isArray(value) ? contentIr.readObjectKind(value) : null) ?? "";
+  const marker = readIrRouteMarker(metadata);
+  const note = marker?.reason === "inactive" ? "a custom view is registered but held inactive" : "no custom view yet";
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: className ? `my-2 min-w-0 ${className}` : "my-2 min-w-0", children: [
+    status === "streaming" ? streamingIndicator ?? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mb-2 text-xs text-muted-foreground", children: "Still arriving\u2026" }) : null,
+    recovered ? host.renderValue({ value, ...kind ? { kind } : {}, note }) : (
+      // Zero-data-loss backstop: the region never parsed, so show the source
+      // verbatim rather than swallowing it.
+      /* @__PURE__ */ jsxRuntime.jsx("pre", { className: "max-h-96 overflow-auto font-mono text-xs leading-relaxed text-muted-foreground", children: content })
+    )
+  ] });
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readWrapperFrom(serverData, read) {
+  if (!isRecord2(serverData)) return null;
+  return read(serverData.wrapper);
+}
+function DelegatedOutput({
+  output,
+  declaredKind,
+  fallback,
+  emptyLabel = "This step ran, and handed its result to the next one."
+}) {
+  const host = useContentIrHost();
+  if (output === null || output === void 0) {
+    return /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-xs text-muted-foreground", children: emptyLabel });
+  }
+  if (!isRecord2(output)) {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: host.renderValue({ value: output }) });
+  }
+  const kind = contentIr.readObjectKind(output) ?? declaredKind;
+  if (!kind) {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: fallback?.(output) ?? host.renderValue({ value: output }) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    KindInstanceRender,
+    {
+      kind,
+      value: output,
+      showRoutingNote: false,
+      variant: "bare",
+      ...fallback === void 0 ? {} : { unroutableFallback: fallback(output) }
+    }
+  );
+}
+function NodeOutcomeView({ serverData, fallback }) {
+  const wrapper = readWrapperFrom(
+    serverData,
+    contentIr.readNodeOutcomeValue
+  );
+  if (!wrapper) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    DelegatedOutput,
+    {
+      output: wrapper.output,
+      declaredKind: wrapper.output_kind,
+      ...fallback === void 0 ? {} : { fallback }
+    }
+  );
+}
+function RunResultView({ serverData, fallback }) {
+  const wrapper = readWrapperFrom(
+    serverData,
+    contentIr.readRunResultValue
+  );
+  if (!wrapper) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-2", children: wrapper.outputs.length > 0 ? wrapper.outputs.map((outcome) => /* @__PURE__ */ jsxRuntime.jsx(
+    NodeOutcomeView,
+    {
+      serverData: { wrapper: outcome },
+      ...fallback === void 0 ? {} : { fallback }
+    },
+    `${outcome.node_id}:${outcome.attempt}`
+  )) : /* @__PURE__ */ jsxRuntime.jsx(
+    DelegatedOutput,
+    {
+      output: wrapper.output,
+      declaredKind: wrapper.output_kind,
+      ...fallback === void 0 ? {} : { fallback }
+    }
+  ) });
+}
+
+exports.ComponentResolver = ComponentResolver;
+exports.ContentIrRenderProvider = ContentIrRenderProvider;
+exports.DB_KIND_COMPONENT_KEY = DB_KIND_COMPONENT_KEY;
+exports.DelegatedOutput = DelegatedOutput;
+exports.GENERIC_STRUCTURED_COMPONENT_KEY = GENERIC_STRUCTURED_COMPONENT_KEY;
+exports.GenericStructuredView = GenericStructuredView;
+exports.IR_PROVISIONAL_KEY = IR_PROVISIONAL_KEY;
+exports.IR_ROUTE_KEY = IR_ROUTE_KEY;
+exports.KindInstanceRender = KindInstanceRender;
+exports.NodeOutcomeView = NodeOutcomeView;
+exports.ProvisionalKindBoundary = ProvisionalKindBoundary;
+exports.ProvisionalKindFrame = ProvisionalKindFrame;
+exports.RunResultView = RunResultView;
+exports.applyIrKindRoute = applyIrKindRoute;
+exports.consoleErrorReporter = consoleErrorReporter;
+exports.envelopeFromPartialKind = envelopeFromPartialKind;
+exports.isPartialReadyKind = isPartialReadyKind;
+exports.isProvisionalBlock = isProvisionalBlock;
+exports.isRecordValue = isRecordValue;
+exports.kindIsRoutable = kindIsRoutable;
+exports.kindServerDataFromStoredValue = kindServerDataFromStoredValue;
+exports.markKindPartialUnsafe = markKindPartialUnsafe;
+exports.readIrRouteMarker = readIrRouteMarker;
+exports.resetPartialUnsafeKinds = resetPartialUnsafeKinds;
+exports.resetSourcelessDbRowReports = resetSourcelessDbRowReports;
+exports.resolveAnnouncedKindLoading = resolveAnnouncedKindLoading;
+exports.resolveProvisionalKindRender = resolveProvisionalKindRender;
+exports.routeEnvOf = routeEnvOf;
+exports.useContentIrHost = useContentIrHost;
+exports.useContentIrHostOrNull = useContentIrHostOrNull;
+exports.useContentIrKindVersion = useContentIrKindVersion;
+exports.useKindRouteEnv = useKindRouteEnv;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map