@alpaca-headless/dynamic-renderings-engine 1.0.4694

package/dist/engine.mjs

@@ -0,0 +1,463 @@
+import { createRequire as __parheliaCreateRequire } from "node:module"; const require = __parheliaCreateRequire(import.meta.url);
+
+// dist/protocol/protocol.js
+var protocol = {
+  /**
+   * The compiler generation. Bump it when compiled output changes in a way a cached bundle or a
+   * CM check must notice. 3: client code (`./client`), browser bundles and first paints.
+   */
+  compiledFormat: 3,
+  limits: {
+    sourceBytes: 204800,
+    cssBytes: 65536,
+    treeBytes: 524288,
+    treeDepth: 64,
+    treeNodes: 2e4,
+    /** Per component: QuickJS's interrupt deadline. */
+    componentMs: 2e3,
+    /** Per page: compiles still missing and all renders. */
+    pageMs: 5e3,
+    /** Per compile, in a compile thread. */
+    buildMs: 2e4,
+    /** V8 heap of a render thread. */
+    threadHeapMb: 128,
+    /** QuickJS memory of one tenant's runtime. */
+    runtimeMemoryMb: 64,
+    /** Render threads (one per active tenant). */
+    maxThreads: 4,
+    /** Compile threads. */
+    maxBuilds: 2
+  },
+  nodeTypes: ["el", "field", "slot", "icon", "translate", "editorFields", "island", "islandChildren", "fragment"],
+  fieldKinds: ["text", "richtext", "picture", "link"],
+  errorCodes: ["module-missing", "timeout", "render-error", "oom", "too-large", "rate-limited", "preparing"],
+  /** `./client` resolves to the rendering's own client code. */
+  serverImports: ["react", "react/jsx-runtime", "@alpaca-headless/alpaca-headless", "./client"],
+  clientImports: ["react", "react/jsx-runtime", "react-dom"],
+  /**
+   * The names client code may import. In the browser they resolve to the head's React, so every
+   * name must exist in the minimum React the host package declares (19.2.0); importing any other
+   * name fails the compile.
+   */
+  browserExports: {
+    react: [
+      "Activity",
+      "Children",
+      "Component",
+      "Fragment",
+      "Profiler",
+      "PureComponent",
+      "StrictMode",
+      "Suspense",
+      "cloneElement",
+      "createContext",
+      "createElement",
+      "createRef",
+      "forwardRef",
+      "isValidElement",
+      "lazy",
+      "memo",
+      "startTransition",
+      "use",
+      "useActionState",
+      "useCallback",
+      "useContext",
+      "useDebugValue",
+      "useDeferredValue",
+      "useEffect",
+      "useEffectEvent",
+      "useId",
+      "useImperativeHandle",
+      "useInsertionEffect",
+      "useLayoutEffect",
+      "useMemo",
+      "useOptimistic",
+      "useReducer",
+      "useRef",
+      "useState",
+      "useSyncExternalStore",
+      "useTransition",
+      "version"
+    ],
+    "react-dom": [
+      "createPortal",
+      "flushSync",
+      "preconnect",
+      "prefetchDNS",
+      "preinit",
+      "preinitModule",
+      "preload",
+      "preloadModule",
+      "requestFormReset",
+      "useFormStatus",
+      "version"
+    ],
+    "react/jsx-runtime": ["jsx", "jsxs", "Fragment"]
+  }
+};
+
+// src/compile-pool.mjs
+import { Worker } from "node:worker_threads";
+var threadUrl = new URL("./compile-thread.mjs", import.meta.url);
+function transient(message) {
+  return { ok: false, transient: true, diagnostics: [{ severity: "error", file: "build", message }] };
+}
+var CompilePool = class {
+  constructor({ size = 2, compileMs, queueLimit = 20, heapMb = 256 }) {
+    this.size = size;
+    this.compileMs = compileMs;
+    this.queueLimit = queueLimit;
+    this.heapMb = heapMb;
+    this.idle = [];
+    this.all = /* @__PURE__ */ new Set();
+    this.queue = [];
+    this.nextJob = 1;
+  }
+  stats() {
+    return { threads: this.all.size, idle: this.idle.length, queued: this.queue.length };
+  }
+  spawn() {
+    const worker = new Worker(threadUrl, {
+      resourceLimits: { maxOldGenerationSizeMb: this.heapMb },
+      env: {},
+      stdout: false,
+      stderr: false
+    });
+    const state = { worker, job: null };
+    state.ready = new Promise((resolve) => worker.once("message", () => resolve()));
+    worker.on("message", (m) => {
+      if (m.type === "built" && state.job && state.job.id === m.jobId) {
+        const job = state.job;
+        state.job = null;
+        clearTimeout(job.timer);
+        job.resolve(m.result);
+        this.release(state);
+      }
+    });
+    const fail = () => {
+      this.all.delete(state);
+      this.idle = this.idle.filter((s) => s !== state);
+      if (state.job) {
+        const job = state.job;
+        state.job = null;
+        clearTimeout(job.timer);
+        job.resolve(transient("The compile thread stopped."));
+      }
+      this.pump();
+    };
+    worker.on("error", fail);
+    worker.on("exit", fail);
+    this.all.add(state);
+    return state;
+  }
+  release(state) {
+    state.worker.unref();
+    this.idle.push(state);
+    this.pump();
+  }
+  pump() {
+    while (this.queue.length) {
+      let state = this.idle.pop();
+      if (!state) {
+        if (this.all.size >= this.size) return;
+        state = this.spawn();
+      }
+      const job = this.queue.shift();
+      this.start(state, job);
+    }
+  }
+  async start(state, job) {
+    state.worker.ref();
+    await state.ready;
+    state.job = job;
+    const remaining = Math.max(1e3, job.deadline - Date.now());
+    job.timer = setTimeout(() => {
+      state.job = null;
+      job.resolve(transient(`The compile took longer than ${this.compileMs} ms.`));
+      state.worker.terminate().catch(() => {
+      });
+    }, remaining);
+    state.worker.postMessage({ type: "build", jobId: job.id, request: job.request });
+  }
+  /** Compiles one rendering. Never rejects; a failure is { ok: false, diagnostics }. */
+  compile(request) {
+    if (this.queue.length >= this.queueLimit) {
+      return Promise.resolve(transient("Too many compiles are queued. Try again shortly."));
+    }
+    return new Promise((resolve) => {
+      this.queue.push({ id: this.nextJob++, request, resolve, deadline: Date.now() + this.compileMs });
+      this.pump();
+    });
+  }
+  async close() {
+    this.queue.length = 0;
+    await Promise.all([...this.all].map((s) => s.worker.terminate().catch(() => {
+    })));
+    this.all.clear();
+    this.idle = [];
+  }
+};
+
+// src/render-pool.mjs
+import { Worker as Worker2 } from "node:worker_threads";
+var threadUrl2 = new URL("./render-thread.mjs", import.meta.url);
+var RenderPool = class {
+  constructor({ limits, maxThreads = limits.maxThreads, idleMs = 5 * 6e4, rate = { perSecond: 40, burst: 200 } }) {
+    this.limits = limits;
+    this.maxThreads = maxThreads;
+    this.idleMs = idleMs;
+    this.rate = rate;
+    this.threads = /* @__PURE__ */ new Map();
+    this.waiting = [];
+    this.modules = /* @__PURE__ */ new Map();
+    this.moduleBytes = 0;
+    this.buckets = /* @__PURE__ */ new Map();
+    this.nextJob = 1;
+    this.sweeper = setInterval(() => this.sweep(), 3e4);
+    this.sweeper.unref();
+  }
+  stats() {
+    return {
+      threads: [...this.threads.values()].map((t) => ({ tenant: t.tenant, busy: t.busy, lastUsed: t.lastUsed })),
+      waiting: this.waiting.length,
+      modules: this.modules.size,
+      moduleBytes: this.moduleBytes
+    };
+  }
+  rememberModules(sources) {
+    const size = (m) => m.server.length + (m.client?.length ?? 0);
+    for (const [buildId, source] of Object.entries(sources || {})) {
+      if (!source || typeof source.server !== "string") continue;
+      const previous = this.modules.get(buildId);
+      if (previous) {
+        this.modules.delete(buildId);
+        this.moduleBytes -= size(previous);
+      }
+      const module = { server: source.server };
+      if (typeof source.client === "string") {
+        module.client = source.client;
+        module.clientExports = Array.isArray(source.clientExports) ? source.clientExports.filter((n) => typeof n === "string") : [];
+      }
+      this.modules.set(buildId, module);
+      this.moduleBytes += size(module);
+    }
+    while (this.moduleBytes > 64 * 1024 * 1024 && this.modules.size > 0) {
+      const [oldest, entry] = this.modules.entries().next().value;
+      this.modules.delete(oldest);
+      this.moduleBytes -= size(entry);
+    }
+  }
+  takeToken(tenant, count) {
+    const now = Date.now();
+    const bucket = this.buckets.get(tenant) || { tokens: this.rate.burst, at: now };
+    bucket.tokens = Math.min(this.rate.burst, bucket.tokens + (now - bucket.at) / 1e3 * this.rate.perSecond);
+    bucket.at = now;
+    this.buckets.set(tenant, bucket);
+    if (bucket.tokens < count) return false;
+    bucket.tokens -= count;
+    return true;
+  }
+  spawn(tenant) {
+    const worker = new Worker2(threadUrl2, {
+      workerData: { limits: this.limits },
+      resourceLimits: { maxOldGenerationSizeMb: this.limits.threadHeapMb, maxYoungGenerationSizeMb: 16 },
+      env: {},
+      stdout: false,
+      stderr: false
+    });
+    const state = { tenant, worker, busy: false, ready: false, lastUsed: Date.now(), job: null };
+    state.readyPromise = new Promise((resolve) => {
+      worker.once("message", (m) => {
+        if (m.type === "ready") {
+          state.ready = true;
+          resolve();
+        }
+      });
+    });
+    worker.on("message", (m) => this.onMessage(state, m));
+    worker.on("error", (err) => this.onDeath(state, err && err.code === "ERR_WORKER_OUT_OF_MEMORY" ? "oom" : "render-error", err));
+    worker.on("exit", () => this.onDeath(state, "render-error"));
+    this.threads.set(tenant, state);
+    return state;
+  }
+  async acquire(tenant) {
+    for (; ; ) {
+      let state = this.threads.get(tenant);
+      if (state && !state.busy) {
+        state.busy = true;
+        return state;
+      }
+      if (!state && this.threads.size < this.maxThreads) {
+        state = this.spawn(tenant);
+        state.busy = true;
+        return state;
+      }
+      if (!state) {
+        const idle = [...this.threads.values()].filter((t) => !t.busy).sort((a, b) => a.lastUsed - b.lastUsed)[0];
+        if (idle) {
+          this.retire(idle);
+          continue;
+        }
+      }
+      await new Promise((resolve) => this.waiting.push(resolve));
+    }
+  }
+  release(state) {
+    state.worker.unref();
+    state.busy = false;
+    state.lastUsed = Date.now();
+    const next = this.waiting.shift();
+    if (next) next();
+  }
+  retire(state) {
+    this.threads.delete(state.tenant);
+    state.retired = true;
+    state.worker.terminate().catch(() => {
+    });
+  }
+  sweep() {
+    const now = Date.now();
+    for (const state of [...this.threads.values()]) {
+      if (!state.busy && now - state.lastUsed > this.idleMs) this.retire(state);
+    }
+  }
+  onMessage(state, message) {
+    const job = state.job;
+    if (!job || message.jobId !== job.id) return;
+    if (message.type === "start") {
+      job.current = message.key;
+      clearTimeout(job.watchdog);
+      job.watchdog = setTimeout(() => this.onDeath(state, "timeout"), this.limits.componentMs + 1500);
+    } else if (message.type === "result") {
+      clearTimeout(job.watchdog);
+      job.current = null;
+      job.results.set(message.key, message);
+    } else if (message.type === "done") {
+      clearTimeout(job.watchdog);
+      state.job = null;
+      job.resolve();
+    }
+  }
+  onDeath(state, code, err) {
+    if (state.dead) return;
+    state.dead = true;
+    if (this.threads.get(state.tenant) === state) this.threads.delete(state.tenant);
+    state.worker.terminate().catch(() => {
+    });
+    const job = state.job;
+    state.job = null;
+    if (job) {
+      clearTimeout(job.watchdog);
+      if (job.current) {
+        const message = code === "oom" ? `The rendering exceeded the ${this.limits.threadHeapMb} MB memory limit.` : code === "timeout" ? `The rendering ran longer than ${this.limits.componentMs} ms.` : "The rendering thread stopped unexpectedly.";
+        job.results.set(job.current, { key: job.current, ok: false, code, message });
+      }
+      job.resolve({ died: true });
+    }
+    if (!state.retired) this.release(state);
+  }
+  async runOnThread(tenant, components, deadline, fresh) {
+    const state = await this.acquire(tenant);
+    state.worker.ref();
+    try {
+      if (!state.ready) await state.readyPromise;
+      const job = { id: this.nextJob++, results: /* @__PURE__ */ new Map(), current: null, watchdog: null };
+      const done = new Promise((resolve) => {
+        job.resolve = resolve;
+      });
+      state.job = job;
+      const modules = {};
+      for (const c of components) {
+        const m = this.modules.get(c.buildId);
+        if (m) modules[c.buildId] = m;
+      }
+      state.worker.postMessage({ type: "render", jobId: job.id, components, modules, fresh: Boolean(fresh) });
+      const remaining = Math.max(0, deadline - Date.now());
+      let pageTimer;
+      const pageTimeout = new Promise((resolve) => {
+        pageTimer = setTimeout(() => resolve({ pageTimeout: true }), remaining);
+      });
+      const outcome = await Promise.race([done, pageTimeout]);
+      clearTimeout(pageTimer);
+      if (outcome && outcome.pageTimeout) {
+        this.onDeath(state, "timeout");
+      }
+      return job.results;
+    } finally {
+      if (!state.dead && !state.retired) this.release(state);
+    }
+  }
+  /**
+   * Renders every component of one tenant for one page. Returns results in request order.
+   * `fresh` runs the job in a context of its own that is discarded afterwards.
+   */
+  async renderPage({ tenant, components, sources, deadlineMs, fresh = false }) {
+    if (!this.takeToken(tenant, components.length)) {
+      return components.map((c) => ({ key: c.key, ok: false, code: "rate-limited", message: "Too many renders for this tenant." }));
+    }
+    this.rememberModules(sources);
+    const deadline = Date.now() + Math.min(deadlineMs || this.limits.pageMs, this.limits.pageMs);
+    const results = /* @__PURE__ */ new Map();
+    let pending = components.filter((c) => {
+      if (this.modules.has(c.buildId)) return true;
+      results.set(c.key, { key: c.key, ok: false, code: "module-missing", message: "Module source not provided." });
+      return false;
+    });
+    while (pending.length && Date.now() < deadline) {
+      const batch = await this.runOnThread(tenant, pending, deadline, fresh);
+      for (const [key, value] of batch) results.set(key, value);
+      pending = pending.filter((c) => !results.has(c.key));
+    }
+    for (const c of pending) {
+      results.set(c.key, { key: c.key, ok: false, code: "timeout", message: `The page's rendering budget of ${this.limits.pageMs} ms ran out.` });
+    }
+    return components.map((c) => {
+      const raw = results.get(c.key);
+      if (raw && typeof raw.json === "string") {
+        try {
+          const parsed = JSON.parse(raw.json);
+          if (parsed.ok) return { key: c.key, ok: true, tree: parsed.tree, ms: raw.ms };
+          return { key: c.key, ok: false, code: parsed.code || "render-error", message: String(parsed.message || ""), logs: parsed.logs, ms: raw.ms };
+        } catch {
+          return { key: c.key, ok: false, code: "render-error", message: "The render result was not valid JSON." };
+        }
+      }
+      return { key: c.key, ok: false, code: raw?.code || "render-error", message: raw?.message || "No result.", ms: raw?.ms };
+    });
+  }
+  async close() {
+    clearInterval(this.sweeper);
+    await Promise.all([...this.threads.values()].map((t) => t.worker.terminate().catch(() => {
+    })));
+    this.threads.clear();
+  }
+};
+
+// src/index.mjs
+function createEngine(options = {}) {
+  const limits = { ...protocol.limits, ...options.limits || {} };
+  const compiler = new CompilePool({
+    size: options.compileThreads ?? limits.maxBuilds,
+    compileMs: limits.buildMs,
+    queueLimit: options.compileQueue ?? 20
+  });
+  const renderer = new RenderPool({
+    limits,
+    maxThreads: options.renderThreads ?? limits.maxThreads,
+    idleMs: options.idleMs,
+    rate: options.rate
+  });
+  return {
+    limits,
+    compile: (request) => compiler.compile(request),
+    renderPage: (request) => renderer.renderPage(request),
+    stats: () => ({ compile: compiler.stats(), render: renderer.stats() }),
+    close: () => Promise.all([compiler.close(), renderer.close()]).then(() => void 0)
+  };
+}
+export {
+  CompilePool,
+  RenderPool,
+  createEngine,
+  protocol
+};

package/dist/protocol/index.d.ts

@@ -0,0 +1,3 @@
+export { protocol } from "./protocol.js";
+export type { Protocol, ProtocolLimits } from "./protocol.js";
+export type * from "./types.js";

package/dist/protocol/index.js

@@ -0,0 +1,2 @@
+// Plain module: no React, no server-only. The engine and next.config.js may import it.
+export { protocol } from "./protocol.js";

package/dist/protocol/protocol.d.ts

@@ -0,0 +1,46 @@
+export declare const protocol: {
+    /**
+     * The compiler generation. Bump it when compiled output changes in a way a cached bundle or a
+     * CM check must notice. 3: client code (`./client`), browser bundles and first paints.
+     */
+    readonly compiledFormat: 3;
+    readonly limits: {
+        readonly sourceBytes: 204800;
+        readonly cssBytes: 65536;
+        readonly treeBytes: 524288;
+        readonly treeDepth: 64;
+        readonly treeNodes: 20000;
+        /** Per component: QuickJS's interrupt deadline. */
+        readonly componentMs: 2000;
+        /** Per page: compiles still missing and all renders. */
+        readonly pageMs: 5000;
+        /** Per compile, in a compile thread. */
+        readonly buildMs: 20000;
+        /** V8 heap of a render thread. */
+        readonly threadHeapMb: 128;
+        /** QuickJS memory of one tenant's runtime. */
+        readonly runtimeMemoryMb: 64;
+        /** Render threads (one per active tenant). */
+        readonly maxThreads: 4;
+        /** Compile threads. */
+        readonly maxBuilds: 2;
+    };
+    readonly nodeTypes: readonly ["el", "field", "slot", "icon", "translate", "editorFields", "island", "islandChildren", "fragment"];
+    readonly fieldKinds: readonly ["text", "richtext", "picture", "link"];
+    readonly errorCodes: readonly ["module-missing", "timeout", "render-error", "oom", "too-large", "rate-limited", "preparing"];
+    /** `./client` resolves to the rendering's own client code. */
+    readonly serverImports: readonly ["react", "react/jsx-runtime", "@alpaca-headless/alpaca-headless", "./client"];
+    readonly clientImports: readonly ["react", "react/jsx-runtime", "react-dom"];
+    /**
+     * The names client code may import. In the browser they resolve to the head's React, so every
+     * name must exist in the minimum React the host package declares (19.2.0); importing any other
+     * name fails the compile.
+     */
+    readonly browserExports: {
+        readonly react: readonly ["Activity", "Children", "Component", "Fragment", "Profiler", "PureComponent", "StrictMode", "Suspense", "cloneElement", "createContext", "createElement", "createRef", "forwardRef", "isValidElement", "lazy", "memo", "startTransition", "use", "useActionState", "useCallback", "useContext", "useDebugValue", "useDeferredValue", "useEffect", "useEffectEvent", "useId", "useImperativeHandle", "useInsertionEffect", "useLayoutEffect", "useMemo", "useOptimistic", "useReducer", "useRef", "useState", "useSyncExternalStore", "useTransition", "version"];
+        readonly "react-dom": readonly ["createPortal", "flushSync", "preconnect", "prefetchDNS", "preinit", "preinitModule", "preload", "preloadModule", "requestFormReset", "useFormStatus", "version"];
+        readonly "react/jsx-runtime": readonly ["jsx", "jsxs", "Fragment"];
+    };
+};
+export type Protocol = typeof protocol;
+export type ProtocolLimits = Protocol["limits"];

package/dist/protocol/protocol.js

@@ -0,0 +1,59 @@
+// What a rendering may use and what it produces: the render-tree node types, the imports a
+// rendering may make, and the limits. The engine (@alpaca-headless/dynamic-renderings-engine) bundles
+// this module when it is built. The host compiles and runs renderings itself, so both sides
+// always come from the same release; compiledFormat only tells the CM (and bundle URLs) which
+// compiler a head runs.
+export const protocol = {
+    /**
+     * The compiler generation. Bump it when compiled output changes in a way a cached bundle or a
+     * CM check must notice. 3: client code (`./client`), browser bundles and first paints.
+     */
+    compiledFormat: 3,
+    limits: {
+        sourceBytes: 204800,
+        cssBytes: 65536,
+        treeBytes: 524288,
+        treeDepth: 64,
+        treeNodes: 20000,
+        /** Per component: QuickJS's interrupt deadline. */
+        componentMs: 2000,
+        /** Per page: compiles still missing and all renders. */
+        pageMs: 5000,
+        /** Per compile, in a compile thread. */
+        buildMs: 20000,
+        /** V8 heap of a render thread. */
+        threadHeapMb: 128,
+        /** QuickJS memory of one tenant's runtime. */
+        runtimeMemoryMb: 64,
+        /** Render threads (one per active tenant). */
+        maxThreads: 4,
+        /** Compile threads. */
+        maxBuilds: 2,
+    },
+    nodeTypes: ["el", "field", "slot", "icon", "translate", "editorFields", "island", "islandChildren", "fragment"],
+    fieldKinds: ["text", "richtext", "picture", "link"],
+    errorCodes: ["module-missing", "timeout", "render-error", "oom", "too-large", "rate-limited", "preparing"],
+    /** `./client` resolves to the rendering's own client code. */
+    serverImports: ["react", "react/jsx-runtime", "@alpaca-headless/alpaca-headless", "./client"],
+    clientImports: ["react", "react/jsx-runtime", "react-dom"],
+    /**
+     * The names client code may import. In the browser they resolve to the head's React, so every
+     * name must exist in the minimum React the host package declares (19.2.0); importing any other
+     * name fails the compile.
+     */
+    browserExports: {
+        react: [
+            "Activity", "Children", "Component", "Fragment", "Profiler", "PureComponent", "StrictMode", "Suspense",
+            "cloneElement", "createContext", "createElement", "createRef", "forwardRef", "isValidElement", "lazy", "memo",
+            "startTransition", "use", "useActionState", "useCallback", "useContext", "useDebugValue", "useDeferredValue",
+            "useEffect", "useEffectEvent", "useId", "useImperativeHandle", "useInsertionEffect", "useLayoutEffect",
+            "useMemo", "useOptimistic", "useReducer", "useRef", "useState", "useSyncExternalStore", "useTransition",
+            "version",
+        ],
+        "react-dom": [
+            "createPortal", "flushSync", "preconnect", "prefetchDNS", "preinit", "preinitModule", "preload",
+            "preloadModule", "requestFormReset", "useFormStatus", "version",
+        ],
+        "react/jsx-runtime": ["jsx", "jsxs", "Fragment"],
+    },
+};

package/dist/protocol/types.d.ts

@@ -0,0 +1,113 @@
+export type ElementNode = {
+    t: "el";
+    tag: string;
+    props: Record<string, unknown>;
+    children: RenderNode[];
+};
+export type FieldNode = {
+    t: "field";
+    kind: "text" | "richtext" | "picture" | "link";
+    field: string;
+    tag?: string;
+    props: Record<string, unknown>;
+    children?: RenderNode[];
+};
+export type SlotNode = {
+    t: "slot";
+    name: string;
+};
+export type IconNode = {
+    t: "icon";
+    name: string;
+    props: Record<string, unknown>;
+};
+export type TranslateNode = {
+    t: "translate";
+    key: string;
+};
+export type EditorFieldsNode = {
+    t: "editorFields";
+    group: string;
+    add: string[];
+    remove: string[];
+};
+/**
+ * A component of the rendering's client code (`./client`), named by its export. `firstPaint` is
+ * that component rendered once in the engine (initial state, no effects); its `islandChildren`
+ * node marks where `children`, rendered by the server code, go.
+ */
+export type IslandNode = {
+    t: "island";
+    name: string;
+    props: Record<string, unknown>;
+    children?: RenderNode[];
+    firstPaint: RenderNode[];
+};
+export type IslandChildrenNode = {
+    t: "islandChildren";
+};
+export type FragmentNode = {
+    t: "fragment";
+    children: RenderNode[];
+};
+export type RenderNode = string | ElementNode | FieldNode | SlotNode | IconNode | TranslateNode | EditorFieldsNode | IslandNode | IslandChildrenNode | FragmentNode;
+export type ComponentDto = {
+    id: string;
+    templateId?: string;
+    language?: string;
+    editing: boolean;
+    fields: Record<string, {
+        name: string;
+        type?: string;
+        value: unknown;
+    }>;
+    placeholders: string[];
+};
+export type RenderResult = {
+    key: string;
+    ok: true;
+    tree: RenderNode[];
+    ms?: number;
+} | {
+    key: string;
+    ok: false;
+    code: string;
+    message: string;
+    logs?: string[];
+    ms?: number;
+};
+/** One rendering in the CM's /alpaca/headless/renderings/sources answer. */
+export type RenderingSource = {
+    id: string;
+    name?: string;
+    kind: "component";
+    tenant: string;
+    code: string;
+    clientCode?: string | null;
+    /** An administrator approved exactly this code. Publishing targets return approved renderings only. */
+    approved: boolean;
+};
+/** The whole /alpaca/headless/renderings/sources answer: the page's renderings and its tenant's theme. */
+export type SourcesResponse = {
+    renderings: RenderingSource[];
+    theme?: {
+        id: string;
+        tokens: string;
+        approved: boolean;
+    } | null;
+};
+/** What a dynamic component needs at render time, computed once per page. */
+export type PreparedComponent = {
+    renderingId: string;
+    buildId?: string;
+    result?: RenderResult;
+    css?: string | null;
+    cssRejected?: string;
+    /** Its compile did not finish within the page budget; it continues in the background. */
+    preparing?: boolean;
+    error?: string;
+    /** First 32 hex digits of the client code's hash, when the rendering has client code. */
+    clientHash?: string;
+    /** The CM reported the rendering as approved. */
+    approved?: boolean;
+};