okno 1.0.0-alpha.8 → 1.0.0-beta.6

package/dist/boot.d.ts

@@ -0,0 +1,88 @@
+/**
+ * okno client boot — production editor delivery.
+ *
+ * In dev the okno Vite plugin injects the editor through dev-server middleware
+ * (`configureServer` in src/vite/plugin.ts). That middleware does not run in a
+ * production build, and on SSG frameworks (Astro et al.) the okno runtime is
+ * server-only — so a deployed page ships no editor at all. This module is the
+ * client-side entry that closes that gap: a page pulls it in (via a framework
+ * integration or a `<script>` in the layout) and it lazily boots the editor on
+ * demand.
+ *
+ * The ~1 MB editor bundle is loaded only when an editor signals intent —
+ * pressing `e`, or visiting with `?okno` / `#okno`. Public visitors download
+ * only this tiny gate. `import("okno/editor")` is a bare specifier the
+ * *consumer's* bundler resolves and code-splits at their build time (okno's own
+ * build keeps it external via rollup `external`), so the editor lands as its own
+ * chunk rather than inside this file.
+ *
+ * FUTURE (not now): this lazy import resolves to the consumer's OWN deployed
+ * chunk, pinned to the okno version they built with — so an editor update needs
+ * a consumer rebuild. An alternative is to load the editor from a hosted URL
+ * (`https://cdn.okno.build/editor@latest`) instead of `import("okno/editor")`:
+ * editors update everywhere with no consumer rebuild, at the cost of version
+ * pinning and a centralized editor↔backend version contract to keep in sync.
+ */
+declare const __OKNO_IS_DEV__: boolean;
+declare const GATE_KEY = "e";
+declare const g: {
+    document?: Document;
+    location?: Location;
+    localStorage?: Storage;
+    __okno_loaded?: boolean;
+    __okno_gate_installed?: boolean;
+    __okno_autostart?: "key" | "url" | "session" | false;
+    __okno_ensure_vt?: () => void;
+};
+declare let loading: boolean;
+declare const OPENED_KEY = "okno-win-opened";
+declare const SHELL_ID = "okno-shadow-root";
+declare const VT_STYLE_ID = "okno-vt-style";
+declare const NAV_CLASS = "okno-nav-vt";
+/** The window was last left open → the editor should ride along across navigation. */
+declare function editorActive(): boolean;
+/** Cross-document View Transitions: needs the VT API + the pageswap/pagereveal
+ *  hooks (Chromium 126+, Safari 18.2+). Elsewhere we degrade to a plain reboot. */
+declare function crossDocVTSupported(): boolean;
+/** Does the HOST page already opt into cross-document View Transitions? Decides
+ *  how we coexist without interfering (see ensureVTStyle). Read before injecting
+ *  our own style; cross-origin sheets are skipped (their rules can't be read). */
+declare function hostHasViewTransition(): boolean;
+/** Inject (once) the rules that hold the editor in place across navigation. Two
+ *  hard constraints: UNIVERSAL (no host-framework assumptions — pure CSS in the
+ *  always-loaded gate) and NON-INTERFERING with the host's own transitions:
+ *   • All `okno-shell` / `root` rules are scoped to `html.okno-nav-vt` — a class
+ *     we set ONLY during a cross-document nav — so they never bleed into okno's
+ *     own same-document structural View Transitions (which run constantly).
+ *   • If the host ALREADY uses cross-document VT, we DON'T touch `root`: the page
+ *     animates exactly as the host intends; we only lift the editor out + hold it.
+ *   • If the host does NOT, we enable a minimal VT and HARD-CUT the page (suppress
+ *     the default root crossfade), so a site that never wanted page transitions
+ *     doesn't suddenly get one — only the editor is held.
+ *  Public on `window.__okno_ensure_vt` so the editor can opt the current page in
+ *  the instant it opens (boot ran here before the window was open). */
+declare function ensureVTStyle(): void;
+/** The editor host is normally a 0-size box (its UI is `position:fixed` inside
+ *  the shadow root), which would snapshot empty and make the browser SKIP the
+ *  transition. Give it a real viewport box + the group name for the capture —
+ *  pointer-events:none so it never intercepts clicks. Inline + transient (only
+ *  during the nav), so it never lingers to fight okno's structural `okno-editor`
+ *  group. Mirrors the structural-edit code in wrap.ts. */
+declare function pinHostForCapture(host: HTMLElement): void;
+/** Outgoing page: flag the nav + lift the editor into its own snapshot group. */
+declare function onPageSwap(e: Event): void;
+/** Incoming page: flag the nav (so the scoped rules apply), then stand up a
+ *  placeholder host with the box + name before first render so the new side has a
+ *  matching `okno-shell` group. `initEditor` reuses it when the bundle loads. The
+ *  flag is cleared once the transition settles. */
+declare function onPageReveal(e: Event): void;
+/** The editor sets `window.__okno_loaded` at the top of its entry module, so
+ *  this flips true the moment the bundle starts evaluating. */
+declare function editorPresent(): boolean;
+/** Don't hijack `e` while the visitor is typing in the host page. Mirrors the
+ *  editor's own focus check (modules/keys.svelte.ts), shadow DOM included. */
+declare function isTyping(): boolean;
+declare function bootEditor(reason: "key" | "url" | "session"): void;
+declare function urlRequestsEditor(): boolean;
+declare function install(): void;
+//# sourceMappingURL=boot.d.ts.map

package/dist/boot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boot.d.ts","sourceRoot":"","sources":["../src/boot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,CAAC,MAAM,eAAe,EAAE,OAAO,CAAA;AAEtC,QAAA,MAAM,QAAQ,MAAM,CAAA;AAEpB,QAAA,MAAM,CAAC,EAA4B;IAClC,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,gBAAgB,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,SAAS,GAAG,KAAK,CAAA;IACpD,gBAAgB,CAAC,EAAE,MAAM,IAAI,CAAA;CAC7B,CAAA;AAED,QAAA,IAAI,OAAO,SAAQ,CAAA;AAenB,QAAA,MAAM,UAAU,oBAAoB,CAAA;AACpC,QAAA,MAAM,QAAQ,qBAAqB,CAAA;AACnC,QAAA,MAAM,WAAW,kBAAkB,CAAA;AACnC,QAAA,MAAM,SAAS,gBAAgB,CAAA;AAE/B,sFAAsF;AACtF,iBAAS,YAAY,IAAI,OAAO,CAM/B;AAED;mFACmF;AACnF,iBAAS,mBAAmB,IAAI,OAAO,CAOtC;AAED;;kFAEkF;AAClF,iBAAS,qBAAqB,IAAI,OAAO,CAgBxC;AAED;;;;;;;;;;;;uEAYuE;AACvE,iBAAS,aAAa,IAAI,IAAI,CA0B7B;AAED;;;;;0DAK0D;AAC1D,iBAAS,iBAAiB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAElD;AAED,iFAAiF;AACjF,iBAAS,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAKlC;AAED;;;mDAGmD;AACnD,iBAAS,YAAY,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAgBpC;AAED;+DAC+D;AAC/D,iBAAS,aAAa,IAAI,OAAO,CAEhC;AAED;8EAC8E;AAC9E,iBAAS,QAAQ,IAAI,OAAO,CAO3B;AAED,iBAAS,UAAU,CAAC,MAAM,EAAE,KAAK,GAAG,KAAK,GAAG,SAAS,GAAG,IAAI,CAa3D;AAED,iBAAS,iBAAiB,IAAI,OAAO,CASpC;AAED,iBAAS,OAAO,IAAI,IAAI,CAgCvB"}

package/dist/boot.js

@@ -1,23 +1,85 @@
-const n = globalThis;
-let o = !1;
-function s() {
-  return !!n.__okno_loaded;
-}
+const e = globalThis;
+let r = !1;
+const m = "okno-win-opened", l = "okno-shadow-root", c = "okno-vt-style", i = "okno-nav-vt";
 function u() {
-  var r, i;
-  let t = (r = n.document) == null ? void 0 : r.activeElement;
-  for (; t && ((i = t.shadowRoot) != null && i.activeElement); )
+  try {
+    return e.localStorage?.getItem(m) === "true";
+  } catch {
+    return !1;
+  }
+}
+function h() {
+  return !!e.document && typeof e.document.startViewTransition == "function" && typeof window < "u" && "onpageswap" in window;
+}
+function _() {
+  if (!e.document) return !1;
+  for (const t of Array.from(e.document.styleSheets)) {
+    if (t.ownerNode?.id === c) continue;
+    let n;
+    try {
+      n = t.cssRules;
+    } catch {
+      continue;
+    }
+    for (const o of Array.from(n))
+      if (o.constructor?.name === "CSSViewTransitionRule" || typeof o.cssText == "string" && o.cssText.trimStart().startsWith("@view-transition")) return !0;
+  }
+  return !1;
+}
+function d() {
+  if (!e.document || e.document.getElementById(c) || !h()) return;
+  const t = _(), n = e.document.createElement("style");
+  n.id = c;
+  let o = `
+html.${i}::view-transition-group(okno-shell) { animation-duration: 420ms; }
+html.${i}::view-transition-old(okno-shell) { animation: okno-shell-hold 420ms both; }
+html.${i}::view-transition-new(okno-shell) { animation: none; }
+@keyframes okno-shell-hold { from { opacity: 1 } to { opacity: 1 } }
+`;
+  t || (o += `
+@view-transition { navigation: auto; }
+html.${i}::view-transition-group(root),
+html.${i}::view-transition-old(root),
+html.${i}::view-transition-new(root) { animation: none; }
+`), n.textContent = o, e.document.head.appendChild(n);
+}
+function w(t) {
+  t.style.cssText += ";position:fixed;inset:0;pointer-events:none;view-transition-name:okno-shell";
+}
+function v(t) {
+  if (!u() || !t.viewTransition) return;
+  e.document?.documentElement.classList.add(i);
+  const n = e.document?.getElementById(l);
+  n instanceof HTMLElement && w(n);
+}
+function y(t) {
+  const n = t.viewTransition;
+  if (!u() || !n || !e.document) return;
+  const o = e.document.documentElement;
+  o.classList.add(i), n.finished?.then?.(
+    () => o.classList.remove(i),
+    () => o.classList.remove(i)
+  );
+  let s = e.document.getElementById(l);
+  s || (s = e.document.createElement("div"), s.id = l, e.document.body.appendChild(s)), s instanceof HTMLElement && (s.style.cssText = "position:fixed;inset:0;pointer-events:none;view-transition-name:okno-shell");
+}
+function f() {
+  return !!e.__okno_loaded;
+}
+function E() {
+  let t = e.document?.activeElement;
+  for (; t && t.shadowRoot?.activeElement; )
     t = t.shadowRoot.activeElement;
-  const e = t == null ? void 0 : t.tagName;
-  return e === "INPUT" || e === "TEXTAREA" || (t == null ? void 0 : t.isContentEditable) === !0;
+  const n = t?.tagName;
+  return n === "INPUT" || n === "TEXTAREA" || t?.isContentEditable === !0;
 }
 function a(t) {
-  o || s() || (o = !0, n.__okno_autostart = t, import("okno/editor").catch((e) => {
-    o = !1, console.error("[okno] failed to load editor bundle", e);
+  r || f() || (r = !0, e.__okno_autostart = t, import("okno/editor").catch((n) => {
+    r = !1, console.error("[okno] failed to load editor bundle", n);
   }));
 }
-function l() {
-  const t = n.location;
+function p() {
+  const t = e.location;
   if (!t) return !1;
   try {
     if (new URLSearchParams(t.search).has("okno")) return !0;
@@ -25,9 +87,12 @@ function l() {
   }
   return typeof t.hash == "string" && /(?:^#|[#&])okno(?:$|[=&])/.test(t.hash);
 }
-function _() {
-  !n.document || typeof __OKNO_IS_DEV__ < "u" && __OKNO_IS_DEV__ || n.__okno_gate_installed || (n.__okno_gate_installed = !0, n.document.addEventListener("keydown", (e) => {
-    s() || e.key !== "e" || e.ctrlKey || e.metaKey || e.altKey || u() || a("key");
-  }), l() && a("url"));
+function g() {
+  if (!e.document || (typeof __OKNO_IS_DEV__ < "u" ? __OKNO_IS_DEV__ : !1) || e.__okno_gate_installed) return;
+  e.__okno_gate_installed = !0, e.document.addEventListener("keydown", (o) => {
+    f() || o.key !== "e" || o.ctrlKey || o.metaKey || o.altKey || E() || a("key");
+  }), e.__okno_ensure_vt = d;
+  const n = window;
+  n.addEventListener("pageswap", v), n.addEventListener("pagereveal", y), u() && (d(), a("session")), p() && a("url");
 }
-_();
+g();

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AA6BA,OAAO,EAAE,CAAA"}

package/dist/cli.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+const [n] = process.argv.slice(2);
+switch (n) {
+  case "mcp": {
+    const { runMcp: o } = await import("./mcp.js");
+    await o();
+    break;
+  }
+  case "help":
+  case "--help":
+  case "-h": {
+    console.log(
+      ["", "  npx okno         Add okno to this project", "  npx okno mcp     Run the okno MCP server (for your AI client)", ""].join(`
+`)
+    );
+    break;
+  }
+  default: {
+    const { runInit: o } = await import("./init.js");
+    await o();
+  }
+}

package/dist/codegen/generate.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Read the schema, scan content directories, and generate:
+ * - modules.d.ts (type declarations for okno:* virtual modules)
+ *
+ * `root` is the project root (parent of the okno dir) — we scan it for
+ * `import { x } from "okno:<kind>"` so names referenced before scaffolding
+ * still get a (placeholder) type, mirroring the runtime virtual modules.
+ */
+export declare function generateTypes(oknoDir: string, root: string): Promise<void>;
+//# sourceMappingURL=generate.d.ts.map

package/dist/codegen/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/codegen/generate.ts"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,iBA4HhE"}

package/dist/codegen/scan-imports.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Walk the project root looking for `import { foo, bar } from "okno:<kind>"`
+ * statements and return the union of imported names. Used by both the runtime
+ * virtual modules and the type codegen to emit placeholder exports for content
+ * that doesn't exist yet, so a project can refer to `home.title` (and get types
+ * for it) before any schema is scaffolded.
+ */
+export declare function scanImports(root: string, kind: "pages" | "collections" | "globals"): Promise<Set<string>>;
+//# sourceMappingURL=scan-imports.d.ts.map

package/dist/codegen/scan-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan-imports.d.ts","sourceRoot":"","sources":["../../src/codegen/scan-imports.ts"],"names":[],"mappings":"AAiBA;;;;;;GAMG;AACH,wBAAsB,WAAW,CAChC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,GAAG,aAAa,GAAG,SAAS,GACvC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CA0CtB"}

package/dist/content-encode-DoojdsVU.js

@@ -0,0 +1,80 @@
+import { p as s } from "./acorn-CZBJD705.js";
+function a(o) {
+  const e = o;
+  switch (e.type) {
+    case "Literal": {
+      if (e.regex) throw new Error("regex literals are not allowed");
+      return e.value;
+    }
+    case "TemplateLiteral": {
+      if (e.expressions.length > 0) throw new Error("template expressions are not allowed");
+      return e.quasis.map((r) => r.value.cooked).join("");
+    }
+    case "UnaryExpression": {
+      if ((e.operator === "-" || e.operator === "+") && e.argument?.type === "Literal" && typeof e.argument.value == "number")
+        return e.operator === "-" ? -e.argument.value : +e.argument.value;
+      throw new Error(`unary operator ${e.operator} is not allowed`);
+    }
+    case "Identifier": {
+      if (e.name === "undefined") return;
+      throw new Error(`identifier ${e.name} is not allowed`);
+    }
+    case "ArrayExpression":
+      return e.elements.map((r) => {
+        if (r === null) throw new Error("array holes are not allowed");
+        if (r.type === "SpreadElement") throw new Error("spread is not allowed");
+        return a(r);
+      });
+    case "ObjectExpression": {
+      const r = {};
+      for (const t of e.properties) {
+        if (t.type !== "Property") throw new Error("spread is not allowed");
+        if (t.computed) throw new Error("computed keys are not allowed");
+        if (t.kind !== "init") throw new Error("getters/setters are not allowed");
+        if (t.method) throw new Error("methods are not allowed");
+        let n;
+        if (t.key.type === "Identifier") n = t.key.name;
+        else if (t.key.type === "Literal") n = String(t.key.value);
+        else throw new Error("unsupported object key");
+        r[n] = a(t.value);
+      }
+      return r;
+    }
+    default:
+      throw new Error(`unsupported node: ${e.type}`);
+  }
+}
+function l(o) {
+  try {
+    let e = o.trim();
+    const r = e.match(/export\s+default\s+([\s\S]+)/);
+    if (!r)
+      return console.warn("Could not find export default"), {};
+    e = r[1].trim(), e.endsWith(";") && (e = e.slice(0, -1)), e = e.replace(/\s+satisfies\s+\w+\s*$/, ""), e = e.replace(/\s+as\s+\w+\s*$/, "");
+    const t = s(`(${e})`, 0, { ecmaVersion: "latest" });
+    return a(t);
+  } catch (e) {
+    return console.error("Failed to parse TypeScript export:", e), {};
+  }
+}
+function p(o, e) {
+  const r = { date: e.now, author: e.author }, t = { ...o, created: e.created ?? r, updated: r };
+  return `export default ${JSON.stringify(t, null, "	")}
+`;
+}
+function u(o, e = `import type { Schema } from "okno"
+
+`) {
+  return `${e}export default ${JSON.stringify(o, null, "	")} satisfies Schema
+`;
+}
+function d(o) {
+  return `export default ${JSON.stringify(o, null, "	")}
+`;
+}
+export {
+  u as a,
+  d as b,
+  p as e,
+  l as p
+};

package/dist/core/content-encode.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Canonical serializers: a content/schema object → its `.ts` source module.
+ *
+ * The byte format is a CONTRACT. The same logical content must encode
+ * identically on the live path (hosted backend → GitHub commit) and the dev
+ * path (local engine → disk write), or a publish round-trip shows phantom
+ * diffs. Keep this module dependency-free (pure string/JSON, no node/svelte) so
+ * either side can import it.
+ *
+ * SYNC: `backend/src/lib/encode.ts` is a byte-identical copy. The backend is a
+ * separate deployable and this monorepo has no cross-package source imports
+ * (same controlled-duplication pattern as this package's
+ * `editor/lib/parse-export-default.ts` ↔ the backend's `lib/parse.ts`). Any
+ * change here MUST be mirrored there, and vice versa.
+ */
+export interface Stamp {
+    date: string;
+    author: string;
+}
+/**
+ * A content entry (page / collection item / global) → `export default {...}`.
+ * Stamps `updated` from `now`/`author`, and `created` from the same stamp unless
+ * a prior `created` is passed through (preserved across edits).
+ *
+ * Key order — content fields, then `created`, then `updated` — is part of the
+ * byte contract. Do not reorder.
+ */
+export declare function encodeEntry(content: Record<string, unknown>, opts: {
+    now: string;
+    author: string;
+    created?: Stamp;
+}): string;
+/**
+ * The schema → `<header>export default {...} satisfies Schema`. `header`
+ * preserves the file's existing import/comment prelude (default: the canonical
+ * `import type { Schema } from "okno"`).
+ */
+export declare function encodeSchema(schema: Record<string, unknown>, header?: string): string;
+/**
+ * Bare `export default <json>` with no metadata — for scaffold seeds (a fresh
+ * page/global's default field values, or an empty `[]` collection).
+ */
+export declare function encodeRaw(value: unknown): string;
+//# sourceMappingURL=content-encode.d.ts.map

package/dist/core/content-encode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-encode.d.ts","sourceRoot":"","sources":["../../src/core/content-encode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,WAAW,KAAK;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;CACd;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAC1B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,IAAI,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,KAAK,CAAA;CAAE,GACpD,MAAM,CAIR;AAED;;;;GAIG;AAGH,wBAAgB,YAAY,CAC3B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,MAAM,SAA2C,GAC/C,MAAM,CAER;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEhD"}

package/dist/core/order.d.ts

@@ -0,0 +1,18 @@
+/**
+ * okno's manual collection ordering — the single source of truth shared by the
+ * build plugin (`okno:collections` iteration order) and the editor (collection
+ * table + reference lists). okno owns ONLY this manual order; any date/field
+ * sort is the dev's own `.sort()` in their template, right before `.map()`.
+ */
+/**
+ * Order `items` by an explicit slug list. Items whose slug appears in `order`
+ * come first, in that order; everything else keeps its original relative order
+ * after them (so items added outside the editor — not yet in `order` — still
+ * show up, just unsorted at the end). Pure and stable; never drops items.
+ */
+export declare function orderBySlugs<T>(items: T[], getSlug: (item: T) => string | undefined, order?: string[]): T[];
+/** Apply a create/delete to a slug-order list. Create prepends (newest-first);
+ *  delete drops the slug. Returns a new array; both are no-ops when redundant. */
+export declare function orderWithInsert(order: string[] | undefined, slug: string): string[];
+export declare function orderWithout(order: string[] | undefined, slug: string): string[];
+//# sourceMappingURL=order.d.ts.map

package/dist/core/order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"order.d.ts","sourceRoot":"","sources":["../../src/core/order.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC7B,KAAK,EAAE,CAAC,EAAE,EACV,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,SAAS,EACxC,KAAK,CAAC,EAAE,MAAM,EAAE,GACd,CAAC,EAAE,CAaL;AAED;kFACkF;AAClF,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAGnF;AACD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAEhF"}

package/dist/core/parse.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Parser for `export default { ... }` TypeScript content/schema files.
+ *
+ * We must NOT execute file content (`new Function` would be an RCE and corrupts
+ * any string containing `//`). Instead we parse the `export default` expression
+ * with acorn and walk the AST, accepting ONLY literal data; anything that would
+ * *evaluate* is rejected.
+ *
+ * PARITY / SYNC: byte-for-byte (parsing logic) with the editor's
+ * `editor/lib/parse-export-default.ts` and the backend's `lib/parse.ts` — THREE
+ * copies of the parser (local vs hosted), keep all in step. This copy lives under
+ * `src/` so the Vite plugin's local engine (which can't import across the editor
+ * `rootDir`) can read schema files. See docs/engine-parity.md.
+ */
+export declare function parseExportDefault(raw: string): Record<string, unknown>;
+//# sourceMappingURL=parse.d.ts.map

package/dist/core/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/core/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAqDH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAyBvE"}