@democraft/compiler 0.1.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Democraft contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,8 @@
+# @democraft/compiler
+
+Captures authored demos into normalized JSON-compatible IR, validates them, and renders readable inspection text.
+
+`compileDemo` remains the compatibility API and returns the IR, compiled config,
+and diagnostics. New library integrations can use `compileDemoResult`, which
+returns `OperationResult<CompiledDemo>` and omits `value` when error diagnostics
+are present. Neither entry point exits the process.

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+import { DemoConfig, DemoDefinition } from '@democraft/core';
+import { OperationResult, DemoIR, Diagnostic } from '@democraft/schema';
+
+type CompilationResult = {
+    ir: DemoIR;
+    config: Pick<DemoConfig, "fps">;
+    diagnostics: Diagnostic[];
+};
+type CompiledDemo = Omit<CompilationResult, "diagnostics">;
+type CompilationOperationResult = OperationResult<CompiledDemo>;
+
+declare function compileDemo(definition: DemoDefinition): Promise<CompilationResult>;
+declare function compileDemoResult(definition: DemoDefinition): Promise<CompilationOperationResult>;
+
+declare function validateIR(ir: DemoIR): Diagnostic[];
+
+declare function inspectIR(ir: DemoIR): string;
+
+declare function parseDurationMs(duration: string): number | null;
+
+declare const DEFINITION_HASH_PREFIX = "definition-v1:sha256:";
+declare const CAPTURE_HASH_PREFIX = "capture-v1:sha256:";
+/**
+ * Returns the deterministic JSON payload used by the definition hash.
+ *
+ * The human id, schema version, and an existing hash are intentionally
+ * excluded. Object keys are sorted recursively while array order is retained.
+ */
+declare function canonicalizeDefinition(ir: Pick<DemoIR, "title" | "source" | "targets" | "scenes" | "visuals">): string;
+declare function createDefinitionHash(ir: Pick<DemoIR, "title" | "source" | "targets" | "scenes" | "visuals">): string;
+/**
+ * Canonical projection of fields that can affect Playwright actions,
+ * screenshots, target snapshots, timings, or capture diagnostics.
+ *
+ * Only fields proven to be presentation-only are excluded. The versioned
+ * prefix must change whenever capture runtime semantics change this boundary.
+ */
+declare function canonicalizeCaptureDefinition(ir: Pick<DemoIR, "source" | "targets" | "scenes">): string;
+declare function createCaptureHash(ir: Pick<DemoIR, "source" | "targets" | "scenes">): string;
+
+export { CAPTURE_HASH_PREFIX, type CompilationOperationResult, type CompilationResult, type CompiledDemo, DEFINITION_HASH_PREFIX, canonicalizeCaptureDefinition, canonicalizeDefinition, compileDemo, compileDemoResult, createCaptureHash, createDefinitionHash, inspectIR, parseDurationMs, validateIR };

package/dist/index.js

@@ -0,0 +1,547 @@
+// src/compile.ts
+import {
+  diagnosticDocsUrl as diagnosticDocsUrl3,
+  schemaVersion
+} from "@democraft/schema";
+
+// src/capture.ts
+function createSceneCapture(steps) {
+  const push = (step) => {
+    steps.push(step);
+    return Promise.resolve();
+  };
+  return {
+    goto: (path, options) => push({ kind: "browser.goto", id: options?.id, path }),
+    click: (target, options) => push({ kind: "browser.click", id: options?.id, target }),
+    fill: (target, value, options) => push({ kind: "browser.fill", id: options?.id, target, value }),
+    select: (target, value, options) => push({ kind: "browser.select", id: options?.id, target, value }),
+    expectVisible: (target, options) => push({ kind: "assert.visible", id: options?.id, target }),
+    expectText: (target, text, options) => push({ kind: "assert.text", id: options?.id, target, text }),
+    expectUrl: (path, options) => push({ kind: "assert.url", id: options?.id, path }),
+    establish: (target, options) => push({ kind: "camera.establish", id: options?.id, target }),
+    focus: (target, options) => push({
+      kind: "camera.focus",
+      id: options?.id,
+      target,
+      padding: options?.padding
+    }),
+    hold: (duration, options) => push({ kind: "timeline.hold", id: options?.id, duration }),
+    transition: (options) => push({
+      kind: "timeline.transition",
+      id: options?.id,
+      transition: options?.type,
+      duration: options?.duration
+    }),
+    caption: (text, options) => push({
+      kind: "overlay.caption",
+      id: options?.id,
+      text,
+      renderer: options?.renderer
+    }),
+    callout: (target, options) => push({
+      kind: "overlay.callout",
+      id: options.id,
+      target,
+      title: options.title,
+      description: options.description,
+      renderer: options.renderer
+    }),
+    visual: (visual, props, options) => push({
+      kind: "overlay.visual",
+      id: options?.id,
+      visual,
+      props,
+      duration: options?.duration
+    }),
+    cue: (name, options) => push({ kind: "cue", id: options?.id, name })
+  };
+}
+
+// src/normalize.ts
+import {
+  diagnosticDocsUrl
+} from "@democraft/schema";
+
+// src/duration.ts
+function parseDurationMs(duration) {
+  const match = /^(\d+(?:\.\d+)?)(ms|s)$/.exec(duration);
+  if (!match) return null;
+  const value = Number(match[1]);
+  if (!Number.isFinite(value) || value < 0) return null;
+  return match[2] === "s" ? Math.round(value * 1e3) : Math.round(value);
+}
+
+// src/normalize.ts
+function normalizeScene(demoId, scene, diagnostics) {
+  return {
+    id: scene.id,
+    purpose: scene.purpose,
+    pacing: scene.pacing ?? "normal",
+    importance: scene.importance ?? "primary",
+    steps: scene.steps.map(
+      (step, index) => normalizeStep(demoId, scene.id, step, index, diagnostics)
+    )
+  };
+}
+function normalizeStep(demoId, sceneId, step, index, diagnostics) {
+  const id = step.id ?? `${sceneId}.${slugStep(step)}.${index + 1}`;
+  switch (step.kind) {
+    case "timeline.hold": {
+      const durationMs = parseDurationMs(step.duration);
+      if (durationMs === null) {
+        diagnostics.push(invalidDuration(demoId, sceneId, id, step.duration));
+      }
+      return { kind: step.kind, id, durationMs: durationMs ?? 0 };
+    }
+    case "timeline.transition": {
+      const durationMs = step.duration ? parseDurationMs(step.duration) : void 0;
+      if (step.duration && durationMs === null) {
+        diagnostics.push(invalidDuration(demoId, sceneId, id, step.duration));
+      }
+      return {
+        kind: step.kind,
+        id,
+        transition: step.transition ?? "cut",
+        durationMs: durationMs ?? void 0
+      };
+    }
+    case "overlay.visual": {
+      const durationMs = step.duration ? parseDurationMs(step.duration) : void 0;
+      if (step.duration && durationMs === null) {
+        diagnostics.push(invalidDuration(demoId, sceneId, id, step.duration));
+      }
+      return {
+        kind: step.kind,
+        id,
+        visual: step.visual,
+        props: step.props && typeof step.props === "object" && !Array.isArray(step.props) ? step.props : { value: step.props },
+        durationMs: durationMs ?? void 0
+      };
+    }
+    default:
+      return { ...step, id };
+  }
+}
+function invalidDuration(demoId, sceneId, stepId, duration) {
+  return {
+    code: "DC102",
+    severity: "error",
+    message: `Invalid duration "${duration}". Use positive values like "250ms", "1s", or "1.5s".`,
+    path: `scenes.${sceneId}.steps.${stepId}.duration`,
+    suggestion: 'Use a duration such as "250ms", "1s", or "1.5s".',
+    docsUrl: diagnosticDocsUrl("DC102"),
+    demoId,
+    sceneId,
+    stepId,
+    details: { duration }
+  };
+}
+function slugStep(step) {
+  const targetOrPath = "target" in step ? step.target : "path" in step ? step.path : "name" in step ? step.name : "";
+  return `${step.kind.replace(".", "-")}-${targetOrPath}`.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+}
+
+// src/validation.ts
+import {
+  diagnosticDocsUrl as diagnosticDocsUrl2
+} from "@democraft/schema";
+function validateIR(ir) {
+  const diagnostics = [];
+  const sceneIds = /* @__PURE__ */ new Set();
+  const visualIds = new Set(ir.visuals ?? []);
+  if (!ir.id || !ir.title || !ir.source.baseUrl) {
+    diagnostics.push({
+      code: "DC001",
+      severity: "error",
+      message: "Demo id, title, and source.baseUrl are required.",
+      path: "demo",
+      suggestion: "Provide non-empty id, title, and source.baseUrl fields.",
+      demoId: ir.id
+    });
+  }
+  for (const [targetKey, target] of Object.entries(ir.targets)) {
+    if (!targetKey || !target.id) {
+      diagnostics.push({
+        code: "DC106",
+        severity: "error",
+        message: "Target ids must be non-empty.",
+        path: `targets.${targetKey || "<empty>"}`,
+        suggestion: "Use a stable non-empty target key.",
+        demoId: ir.id,
+        targetId: target.id || targetKey
+      });
+    }
+    if (!Array.isArray(target.locators) || target.locators.length === 0) {
+      diagnostics.push({
+        code: "DC106",
+        severity: "error",
+        message: `Target "${target.id || targetKey}" must define at least one locator.`,
+        path: `targets.${targetKey}.locators`,
+        suggestion: "Add at least one locator such as byRole() or byTestId().",
+        demoId: ir.id,
+        targetId: target.id || targetKey
+      });
+    }
+  }
+  for (const scene of ir.scenes) {
+    if (!scene.id) {
+      diagnostics.push({
+        code: "DC103",
+        severity: "error",
+        message: "Scene ids must be non-empty.",
+        path: "scenes",
+        suggestion: "Give every scene a stable non-empty id.",
+        demoId: ir.id
+      });
+    }
+    if (sceneIds.has(scene.id)) {
+      diagnostics.push({
+        code: "DC002",
+        severity: "error",
+        message: `Duplicate scene id "${scene.id}".`,
+        path: `scenes.${scene.id}`,
+        suggestion: "Rename one of the scenes so every scene id is unique.",
+        demoId: ir.id,
+        sceneId: scene.id
+      });
+    }
+    sceneIds.add(scene.id);
+    const stepIds = /* @__PURE__ */ new Set();
+    for (const step of scene.steps) {
+      if (!step.id) {
+        diagnostics.push({
+          code: "DC104",
+          severity: "error",
+          message: "Step ids must be non-empty.",
+          path: `scenes.${scene.id}.steps`,
+          suggestion: "Remove the empty id to generate one or provide a stable id.",
+          demoId: ir.id,
+          sceneId: scene.id
+        });
+      }
+      if (stepIds.has(step.id)) {
+        diagnostics.push({
+          code: "DC002",
+          severity: "error",
+          message: `Duplicate step id "${step.id}".`,
+          path: `scenes.${scene.id}.steps.${step.id}`,
+          suggestion: "Rename one of the steps so every step id is unique.",
+          demoId: ir.id,
+          sceneId: scene.id,
+          stepId: step.id
+        });
+      }
+      stepIds.add(step.id);
+      const hasTarget = "target" in step;
+      const target = hasTarget ? step.target : void 0;
+      if (hasTarget && !target) {
+        diagnostics.push({
+          code: "DC106",
+          severity: "error",
+          message: "Step target ids must be non-empty.",
+          path: `scenes.${scene.id}.steps.${step.id}.target`,
+          suggestion: "Use one of the target ids declared in targets.",
+          demoId: ir.id,
+          sceneId: scene.id,
+          stepId: step.id
+        });
+      } else if (target && !ir.targets[target]) {
+        diagnostics.push({
+          code: "DC101",
+          severity: "error",
+          message: `Unknown target "${target}".`,
+          path: `scenes.${scene.id}.steps.${step.id}.target`,
+          suggestion: unknownTargetSuggestion(target, Object.keys(ir.targets)),
+          demoId: ir.id,
+          sceneId: scene.id,
+          stepId: step.id,
+          targetId: target
+        });
+      }
+      if (step.kind === "overlay.visual") {
+        if (!visualIds.has(step.visual)) {
+          diagnostics.push({
+            code: "DC107",
+            severity: "error",
+            message: `Unknown visual "${step.visual}".`,
+            path: `scenes.${scene.id}.steps.${step.id}.visual`,
+            suggestion: visualIds.size === 0 ? `Declare "${step.visual}" in the demo visuals map.` : `Use one of the declared visuals: ${[...visualIds].join(", ")}.`,
+            demoId: ir.id,
+            sceneId: scene.id,
+            stepId: step.id
+          });
+        }
+        if (!isJsonValue(step.props)) {
+          diagnostics.push({
+            code: "DC108",
+            severity: "error",
+            message: `Visual "${step.visual}" props must be JSON-serializable.`,
+            path: `scenes.${scene.id}.steps.${step.id}.props`,
+            suggestion: "Use only strings, numbers, booleans, null, arrays, and plain objects as visual props.",
+            demoId: ir.id,
+            sceneId: scene.id,
+            stepId: step.id
+          });
+        }
+      }
+    }
+  }
+  return diagnostics.map((diagnostic) => ({
+    ...diagnostic,
+    docsUrl: diagnostic.docsUrl ?? diagnosticDocsUrl2(diagnostic.code)
+  }));
+}
+function isJsonValue(value, seen = /* @__PURE__ */ new Set()) {
+  if (value === null) return true;
+  if (["string", "boolean"].includes(typeof value)) return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value !== "object") return false;
+  if (seen.has(value)) return false;
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const valid2 = value.every((item) => isJsonValue(item, seen));
+    seen.delete(value);
+    return valid2;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return false;
+  const valid = Object.values(value).every((item) => isJsonValue(item, seen));
+  seen.delete(value);
+  return valid;
+}
+function unknownTargetSuggestion(target, targetIds) {
+  if (targetIds.length === 0) {
+    return `Declare "${target}" in targets.`;
+  }
+  return `Declare "${target}" in targets or use one of: ${targetIds.join(", ")}.`;
+}
+
+// src/definition-hash.ts
+import { createHash } from "crypto";
+var DEFINITION_HASH_PREFIX = "definition-v1:sha256:";
+var CAPTURE_HASH_PREFIX = "capture-v1:sha256:";
+function canonicalizeDefinition(ir) {
+  return canonicalJson({
+    title: ir.title,
+    source: ir.source,
+    targets: ir.targets,
+    visuals: ir.visuals,
+    scenes: ir.scenes
+  });
+}
+function createDefinitionHash(ir) {
+  return `${DEFINITION_HASH_PREFIX}${sha256(canonicalizeDefinition(ir))}`;
+}
+function canonicalizeCaptureDefinition(ir) {
+  return canonicalJson({
+    source: { baseUrl: ir.source.baseUrl },
+    targets: Object.fromEntries(
+      Object.entries(ir.targets).map(([id, target]) => [
+        id,
+        { id: target.id, locators: target.locators }
+      ])
+    ),
+    scenes: ir.scenes.map((scene) => ({
+      id: scene.id,
+      steps: scene.steps.map(captureStepProjection)
+    }))
+  });
+}
+function createCaptureHash(ir) {
+  return `${CAPTURE_HASH_PREFIX}${sha256(canonicalizeCaptureDefinition(ir))}`;
+}
+function captureStepProjection(step) {
+  const identity = { id: step.id, kind: step.kind };
+  switch (step.kind) {
+    case "browser.goto":
+    case "assert.url":
+      return { ...identity, path: step.path };
+    case "browser.click":
+    case "assert.visible":
+    case "camera.establish":
+      return { ...identity, target: step.target };
+    case "browser.fill":
+    case "browser.select":
+      return { ...identity, target: step.target, value: step.value };
+    case "assert.text":
+      return { ...identity, target: step.target, text: step.text };
+    case "camera.focus":
+      return { ...identity, target: step.target };
+    case "timeline.hold":
+    case "timeline.transition":
+      return { ...identity, durationMs: step.durationMs };
+    case "overlay.caption":
+      return { ...identity, text: step.text };
+    case "overlay.callout":
+      return {
+        ...identity,
+        target: step.target,
+        title: step.title,
+        description: step.description
+      };
+    case "overlay.visual":
+      return identity;
+    case "cue":
+      return identity;
+  }
+}
+function sha256(value) {
+  return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function canonicalJson(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => item === void 0 ? "null" : canonicalJson(item)).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+    return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`).join(",")}}`;
+  }
+  const serialized = JSON.stringify(value);
+  if (serialized === void 0) {
+    throw new TypeError("Definition contains a non-JSON value.");
+  }
+  return serialized;
+}
+
+// src/compile.ts
+async function compileDemo(definition) {
+  const diagnostics = [];
+  const capturedScenes = [];
+  const fps = definition.config?.fps;
+  const hasValidFps = fps === void 0 || Number.isFinite(fps) && fps > 0;
+  if (!hasValidFps) {
+    diagnostics.push({
+      code: "DC001",
+      severity: "error",
+      message: "Config fps must be a finite number greater than 0.",
+      path: "config.fps",
+      suggestion: "Use a positive FPS such as 30 or 60.",
+      docsUrl: diagnosticDocsUrl3("DC001"),
+      demoId: definition.id
+    });
+  }
+  const demo = {
+    async scene(id, metadataOrRun, maybeRun) {
+      const metadata = typeof metadataOrRun === "function" ? {} : metadataOrRun;
+      const run = typeof metadataOrRun === "function" ? metadataOrRun : maybeRun;
+      const steps = [];
+      if (!run) {
+        diagnostics.push({
+          code: "DC103",
+          severity: "error",
+          message: `Scene "${id}" is missing a run callback.`,
+          path: `scenes.${id}`,
+          suggestion: "Pass a scene callback as the final argument.",
+          docsUrl: diagnosticDocsUrl3("DC103"),
+          demoId: definition.id,
+          sceneId: id
+        });
+        return;
+      }
+      await run(createSceneCapture(steps));
+      capturedScenes.push({ id, ...metadata, steps });
+    }
+  };
+  try {
+    await definition.run({ demo });
+  } catch (error) {
+    diagnostics.push({
+      code: "DC003",
+      severity: "error",
+      message: error instanceof Error ? error.message : "Demo capture failed.",
+      path: "run",
+      suggestion: "Fix the exception thrown by the demo run callback.",
+      docsUrl: diagnosticDocsUrl3("DC003"),
+      demoId: definition.id
+    });
+  }
+  const ir = {
+    schemaVersion,
+    id: definition.id,
+    title: definition.title,
+    source: definition.source,
+    targets: definition.targets,
+    visuals: Object.keys(definition.visuals ?? {}),
+    scenes: capturedScenes.map(
+      (scene) => normalizeScene(definition.id, scene, diagnostics)
+    )
+  };
+  const validationDiagnostics = validateIR(ir);
+  diagnostics.push(...validationDiagnostics);
+  if (!validationDiagnostics.some((diagnostic) => diagnostic.code === "DC108")) {
+    ir.definitionHash = createDefinitionHash(ir);
+  }
+  ir.captureHash = createCaptureHash(ir);
+  return {
+    ir,
+    config: fps === void 0 || !hasValidFps ? {} : { fps },
+    diagnostics
+  };
+}
+async function compileDemoResult(definition) {
+  const { ir, config, diagnostics } = await compileDemo(definition);
+  if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+    return { ok: false, diagnostics };
+  }
+  return { ok: true, value: { ir, config }, diagnostics };
+}
+
+// src/inspect.ts
+function inspectIR(ir) {
+  const lines = [ir.title.toUpperCase(), ""];
+  for (const scene of ir.scenes) {
+    lines.push(`Scene: ${scene.id}`, "");
+    scene.steps.forEach((step, index) => {
+      lines.push(`${index + 1}. ${describeStep(step)}`);
+    });
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+function describeStep(step) {
+  switch (step.kind) {
+    case "browser.goto":
+      return `Go to "${step.path}"`;
+    case "browser.click":
+      return `Click target "${step.target}"`;
+    case "browser.fill":
+      return `Fill target "${step.target}" with "${step.value}"`;
+    case "browser.select":
+      return `Select "${step.value}" in target "${step.target}"`;
+    case "assert.visible":
+      return `Expect target "${step.target}" to be visible`;
+    case "assert.text":
+      return `Expect target "${step.target}" to contain "${step.text}"`;
+    case "assert.url":
+      return `Expect URL "${step.path}"`;
+    case "camera.establish":
+      return step.target ? `Establish camera on "${step.target}"` : "Establish camera";
+    case "camera.focus":
+      return `Focus camera on "${step.target}"`;
+    case "timeline.hold":
+      return `Hold for ${step.durationMs}ms`;
+    case "timeline.transition":
+      return step.durationMs ? `Transition with ${step.transition} for ${step.durationMs}ms` : `Transition with ${step.transition}`;
+    case "overlay.caption":
+      return `Show caption "${step.text}"`;
+    case "overlay.callout":
+      return `Show callout "${step.title}" on "${step.target}"`;
+    case "overlay.visual":
+      return `Show visual "${step.visual}"`;
+    case "cue":
+      return `Create cue "${step.name}"`;
+  }
+}
+export {
+  CAPTURE_HASH_PREFIX,
+  DEFINITION_HASH_PREFIX,
+  canonicalizeCaptureDefinition,
+  canonicalizeDefinition,
+  compileDemo,
+  compileDemoResult,
+  createCaptureHash,
+  createDefinitionHash,
+  inspectIR,
+  parseDurationMs,
+  validateIR
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@democraft/compiler",
+  "version": "0.1.0-beta.0",
+  "description": "Compiler and validation pipeline for Democraft definitions.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/felipersas/democraft.git",
+    "directory": "packages/compiler"
+  },
+  "homepage": "https://github.com/felipersas/democraft#readme",
+  "bugs": "https://github.com/felipersas/democraft/issues",
+  "engines": {
+    "node": ">=20"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@democraft/core": "0.1.0-beta.0",
+    "@democraft/schema": "0.1.0-beta.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}