@nilvn/core 0.14.0

package/dist/screenplay-format.js

@@ -0,0 +1,96 @@
+// Screenplay contract, formatter half (see screenplay.ts for the contract
+// overview). formatScreenplay pulls human-written deviations back to the strict
+// grammar-v1 form — lenient parsing is format→parse, one parser code path.
+//
+// Normalization comes in two tiers:
+//   1. Control characters (unconditional, STRUCTURAL positions only): speaker
+//      colon `：`→`:` + mood parens `（）`→`()` (guarded by the ≤4-char
+//      no-punctuation prefix heuristic so prose with a full-width colon is left
+//      alone), `->`→`→` before link targets on `>`/`-` lines, and legacy
+//      pandoc `{#id}` heading anchors → trailing code spans.
+//   2. Body punctuation style (per-project configurable): quote pairs and
+//      ellipses unified to ONE form so short-label matching, cross-paragraph
+//      references and translation catalogs never break on mixed styles.
+//      (Dash normalization is deliberately left out: `---` collides with
+//      markdown thematic breaks / frontmatter fences.)
+//
+// Invariants (each is a test): idempotent; meaning-preserving (glyphs change,
+// the play does not); code spans, link targets and fenced blocks are never
+// touched; lines are never merged or split.
+// Speaker-colon disambiguation: a prefix of at most 4 letter/number characters
+// (no punctuation, no spaces) followed by a colon reads as a speaker; anything
+// longer or punctuated is prose. The rewrite only fires when a FULL-WIDTH
+// structural char (：（）) is present — an all-half-width line is either
+// already strict or intentional prose (`12:30 kickoff` must not gain a space).
+const SPEAKER_RE = /^([\p{L}\p{N}]{1,4})(?:([（(])([^()（）]{0,16})([)）]))?([：:])\s?(.*)$/u;
+const INNER_SPEAKER_RE = /^(\*\()([\p{L}\p{N}]{1,4})：\s?(.*\)\*)$/u;
+const LEGACY_ANCHOR_RE = /^(#{1,6} .*?)\s*\{#([^}]+)\}\s*$/;
+const ARROW_BEFORE_LINK_RE = /\s*->\s*(?=\[)/g;
+export function formatScreenplay(text, opts = {}) {
+    const quoteStyle = opts.quoteStyle ?? '"';
+    const ellipsis = opts.ellipsis ?? '……';
+    const newline = text.includes('\r\n') ? '\r\n' : '\n';
+    const lines = text.split(/\r\n?|\n/);
+    let inFence = false;
+    const out = lines.map((raw) => {
+        if (/^```/.test(raw.trimStart())) {
+            inFence = !inFence;
+            return raw;
+        }
+        if (inFence)
+            return raw;
+        let line = raw.trimEnd();
+        // Tier 1 — structural control characters.
+        line = line.replace(LEGACY_ANCHOR_RE, (_, head, id) => `${head} \`${id}\``);
+        if (line.startsWith('>') || line.startsWith('- ')) {
+            line = line.replace(ARROW_BEFORE_LINK_RE, ' → ');
+        }
+        const speaker = line.match(SPEAKER_RE);
+        if (speaker && (speaker[5] === '：' || speaker[2] === '（' || speaker[4] === '）')) {
+            line = `${speaker[1]}${speaker[3] ? `(${speaker[3]})` : ''}: ${speaker[6]}`;
+        }
+        else {
+            const inner = line.match(INNER_SPEAKER_RE);
+            if (inner)
+                line = `${inner[1]}${inner[2]}: ${inner[3]}`;
+        }
+        // Tier 2 — body punctuation, skipping code spans and link targets.
+        return mapUnprotected(line, (seg) => {
+            // ASCII `...` and doubled-up `…` runs unify; a lone `…` is a legitimate
+            // short pause and stays.
+            let s = ellipsis === '……' ? seg.replace(/\.{3,}/g, '……').replace(/…{2,}/g, '……') : seg.replace(/…+|\.{3,}/g, '...');
+            if (quoteStyle === '"') {
+                s = s.replace(/[“”「」]/g, '"');
+            }
+            else {
+                s = s.replace(/「/g, quoteStyle[0]).replace(/」/g, quoteStyle[1]);
+                s = s.replace(/“/g, quoteStyle[0]).replace(/”/g, quoteStyle[1]);
+            }
+            return s;
+        }, quoteStyle);
+    });
+    return out.join(newline);
+}
+// Split a line into protected (code spans, `](target)` link tails) and open
+// segments, apply fn to the open ones. Straight-quote → directional conversion
+// needs pairing state, carried across the open segments of one line (opening
+// and closing quotes are assumed to sit in the same line — catalog values are
+// single-line by construction, see catalog.ts).
+function mapUnprotected(line, fn, quoteStyle) {
+    const parts = line.split(/(`[^`]*`|\]\([^)]*\))/);
+    let quoteOpen = false;
+    return parts
+        .map((part, i) => {
+        if (i % 2 === 1)
+            return part; // protected: code span or link target
+        let s = fn(part);
+        if (quoteStyle !== '"') {
+            s = s.replace(/"/g, () => {
+                quoteOpen = !quoteOpen;
+                return quoteOpen ? quoteStyle[0] : quoteStyle[1];
+            });
+        }
+        return s;
+    })
+        .join('');
+}

package/dist/screenplay.d.ts

@@ -0,0 +1,99 @@
+/** A `[label](target)` markdown link as used by jumps and branch options.
+ *  `target` splits into `file` (cross-file: `ch02.md#open`) and/or `anchor`
+ *  (in-file: `#relief`); both stay undefined when the target has neither shape. */
+export interface ScreenplayLink {
+    label: string;
+    /** `ch02.md` in `ch02.md#open`; undefined for in-file targets. */
+    file?: string;
+    /** `open` in `ch02.md#open` or `#open`; undefined when the link has no `#` part. */
+    anchor?: string;
+    /** The raw target text between the parentheses, verbatim. */
+    raw: string;
+}
+/** One `- **label** → [target](#id)：consequence` list item. Everything past
+ *  the bold label is optional: an option with no target imports as unwired. */
+export interface ScreenplayOption {
+    label: string;
+    /** Natural-language condition from a `*(if …)*` prefix, parens content verbatim. */
+    condition?: string;
+    target?: ScreenplayLink;
+    /** Prose consequence after the (full- or half-width) colon following the target. */
+    consequence?: string;
+    line: number;
+}
+export type ScreenplayEvent = 
+/** `# Chapter 1 · Rooftop` — chapter heading (file-tree level concept downstream). */
+{
+    kind: 'chapter';
+    title: string;
+    line: number;
+}
+/** `` ## Scene · Classroom `dusk` `` — the trailing code span is the anchor id. */
+ | {
+    kind: 'sceneHeading';
+    title: string;
+    id?: string;
+    line: number;
+}
+/** `name(mood): text` — half-width colon + space is the anchor; mood optional. */
+ | {
+    kind: 'say';
+    name: string;
+    mood?: string;
+    text: string;
+    line: number;
+}
+/** Bare prose line (the fallback for story text). Inline `**…**` / `` `…` ``
+ *  markers are kept verbatim; strip with stripScreenplayMarkup at import. */
+ | {
+    kind: 'narrate';
+    text: string;
+    line: number;
+}
+/** Whole-line `*(……)*` first-person inner monologue; `*(name: ……)*` named. */
+ | {
+    kind: 'inner';
+    name?: string;
+    text: string;
+    line: number;
+}
+/** Whole-line `**……**` action/emotion beat. */
+ | {
+    kind: 'beat';
+    text: string;
+    line: number;
+}
+/** `>` prose block that is neither a jump nor a branch prompt — a director
+ *  note. Consecutive `>` lines merge (joined with newlines). */
+ | {
+    kind: 'note';
+    text: string;
+    line: number;
+}
+/** A run of option list items, with the immediately preceding `>` prose block
+ *  (if any) attached as the prompt ("player chooses here" marker — its absence
+ *  means the branch is state-driven). */
+ | {
+    kind: 'branch';
+    prompt?: string;
+    options: ScreenplayOption[];
+    line: number;
+}
+/** `> → [label](#anchor)` — unconditional jump. */
+ | {
+    kind: 'jump';
+    target: ScreenplayLink;
+    line: number;
+}
+/** Anything the grammar does not define (tables, plain list items, deep
+ *  headings, fenced code…). Kept verbatim so importers can count and report. */
+ | {
+    kind: 'unknown';
+    raw: string;
+    line: number;
+};
+export declare function parseScreenplayLink(label: string, rawTarget: string): ScreenplayLink;
+export declare function parseScreenplay(text: string): ScreenplayEvent[];
+/** Strip the inline markers grammar v1 allows inside prose — bold emphasis and
+ *  machine-word code spans — keeping the text (what an import keeps). */
+export declare function stripScreenplayMarkup(text: string): string;

package/dist/screenplay.js

@@ -0,0 +1,161 @@
+// Screenplay contract, parser half. Grammar v1 ("render-first markdown") is
+// specified by the grammar table the writing tools ship; the three artifacts
+// (grammar table, this parser, screenplay-format.ts) must stay in lockstep, and
+// the tools' sample screenplay doubles as the round-trip test corpus.
+//
+// parseScreenplay is STRICT and line-based: it only recognizes the canonical
+// half-width forms and never guesses. Human-written
+// deviations (full-width colons, `->` arrows, legacy `{#id}` anchors) are the
+// formatter's job — lenient parsing is `parseScreenplay(formatScreenplay(x))`,
+// a single parser code path.
+//
+// The output is a flat event stream, NOT IR: mapping events onto scenes/nodes
+// (actor resolution, mood→face, wiring) is a downstream editorial decision
+// (editor paste-import, nilvn-director, M6 validators).
+// Speaker anchor: 1–12 chars with no whitespace/colon/paren, optional
+// half-width (mood), then ": " (half-width colon + space). Kept deliberately
+// permissive on the name charset — the ≤4-char heuristic belongs to the
+// FORMATTER's full-width disambiguation, not to the strict form.
+const SAY_RE = /^([^\s:：()（）]{1,12})(?:\(([^()]*)\))?: (.*)$/;
+const HEADING_SCENE_RE = /^## (.*?)(?:\s+`([^`]+)`)?\s*$/;
+const INNER_RE = /^\*\((.+)\)\*$/;
+const BEAT_RE = /^\*\*(.+)\*\*$/;
+const JUMP_RE = /^>\s*→\s*\[(.+?)\]\(([^)]*)\)\s*$/;
+const OPTION_RE = /^- (?:\*\(([^)]*)\)\*\s+)?\*\*(.+?)\*\*(?:\s*→\s*\[(.+?)\]\(([^)]*)\))?\s*(?:[：:]\s*(.*))?$/;
+const LINK_TARGET_RE = /^(?:([^#\s)]+\.md))?(?:#([^\s)]+))?$/;
+// Lines the grammar deliberately does not define: tables, non-option list
+// items, thematic breaks, deep/malformed headings, raw HTML.
+const UNDEFINED_LINE_RE = /^(\||[-*+] |\d+[.)] |#{3,}|#[^ ]|---\s*$|<)/;
+export function parseScreenplayLink(label, rawTarget) {
+    const m = rawTarget.match(LINK_TARGET_RE);
+    const link = { label, raw: rawTarget };
+    if (m && (m[1] || m[2])) {
+        if (m[1])
+            link.file = m[1];
+        if (m[2])
+            link.anchor = m[2];
+    }
+    return link;
+}
+export function parseScreenplay(text) {
+    const events = [];
+    const lines = text.split(/\r\n?|\n/);
+    // A trailing `>` prose block waiting to become either a branch prompt (if an
+    // option list follows across at most blank lines) or a standalone note.
+    let pendingNote = null;
+    let branch = null;
+    let inFence = false;
+    const flushNote = () => {
+        if (!pendingNote)
+            return;
+        events.push({ kind: 'note', text: pendingNote.text.join('\n'), line: pendingNote.line });
+        pendingNote = null;
+    };
+    const flushBranch = () => {
+        if (!branch)
+            return;
+        events.push({ kind: 'branch', prompt: branch.prompt, options: branch.options, line: branch.line });
+        branch = null;
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const raw = lines[i];
+        const lineNo = i + 1;
+        const line = raw.trimEnd();
+        if (/^```/.test(line.trimStart())) {
+            flushNote();
+            flushBranch();
+            inFence = !inFence;
+            events.push({ kind: 'unknown', raw, line: lineNo });
+            continue;
+        }
+        if (inFence) {
+            events.push({ kind: 'unknown', raw, line: lineNo });
+            continue;
+        }
+        if (line === '')
+            continue; // blank lines keep pendingNote/branch open
+        const option = line.match(OPTION_RE);
+        if (option) {
+            if (!branch) {
+                branch = { options: [], line: pendingNote ? pendingNote.line : lineNo };
+                if (pendingNote) {
+                    branch.prompt = pendingNote.text.join('\n');
+                    pendingNote = null;
+                }
+            }
+            const opt = { label: option[2], line: lineNo };
+            if (option[1] !== undefined)
+                opt.condition = option[1];
+            if (option[3] !== undefined)
+                opt.target = parseScreenplayLink(option[3], option[4] ?? '');
+            if (option[5])
+                opt.consequence = option[5];
+            branch.options.push(opt);
+            continue;
+        }
+        // Any non-blank, non-option line closes an open branch.
+        flushBranch();
+        if (line.startsWith('>')) {
+            const jump = line.match(JUMP_RE);
+            if (jump) {
+                flushNote();
+                events.push({ kind: 'jump', target: parseScreenplayLink(jump[1], jump[2] ?? ''), line: lineNo });
+                continue;
+            }
+            const text = line.replace(/^>\s?/, '');
+            if (pendingNote)
+                pendingNote.text.push(text);
+            else
+                pendingNote = { text: [text], line: lineNo };
+            continue;
+        }
+        flushNote();
+        if (line.startsWith('# ')) {
+            events.push({ kind: 'chapter', title: line.slice(2).trim(), line: lineNo });
+            continue;
+        }
+        const scene = line.startsWith('## ') ? line.match(HEADING_SCENE_RE) : null;
+        if (scene) {
+            const ev = { kind: 'sceneHeading', title: scene[1].trim(), line: lineNo };
+            if (scene[2])
+                ev.id = scene[2];
+            events.push(ev);
+            continue;
+        }
+        if (UNDEFINED_LINE_RE.test(line)) {
+            events.push({ kind: 'unknown', raw, line: lineNo });
+            continue;
+        }
+        const inner = line.match(INNER_RE);
+        if (inner) {
+            const named = inner[1].match(/^([^\s:：()（）]{1,12}): (.*)$/);
+            if (named)
+                events.push({ kind: 'inner', name: named[1], text: named[2], line: lineNo });
+            else
+                events.push({ kind: 'inner', text: inner[1], line: lineNo });
+            continue;
+        }
+        const beat = line.match(BEAT_RE);
+        if (beat) {
+            events.push({ kind: 'beat', text: beat[1], line: lineNo });
+            continue;
+        }
+        const say = line.match(SAY_RE);
+        if (say) {
+            const ev = { kind: 'say', name: say[1], text: say[3], line: lineNo };
+            if (say[2])
+                ev.mood = say[2];
+            events.push(ev);
+            continue;
+        }
+        events.push({ kind: 'narrate', text: line, line: lineNo });
+    }
+    flushBranch();
+    flushNote();
+    return events;
+}
+/** Strip the inline markers grammar v1 allows inside prose — bold emphasis and
+ *  machine-word code spans — keeping the text (what an import keeps). */
+export function stripScreenplayMarkup(text) {
+    return text.replace(/\*\*([^*]+)\*\*/g, '$1').replace(/`([^`]+)`/g, '$1');
+}

package/dist/semver.d.ts

@@ -0,0 +1,15 @@
+export interface SemVer {
+    major: number;
+    minor: number;
+    patch: number;
+    pre?: string;
+}
+/** Parse `x.y.z[-pre]`; missing minor / patch read as 0. null when malformed. */
+export declare function parseSemVer(v: string): SemVer | null;
+/** Standard ordering: numeric triple, then a prerelease sorts BELOW its release. */
+export declare function compareSemVer(a: SemVer, b: SemVer): number;
+/** Is `range` well-formed in this subset? (Empty / `*` count as valid.) */
+export declare function isValidRange(range: string | undefined): boolean;
+/** Does `version` satisfy `range`? A malformed version never does; a malformed
+ *  range never matches either (callers validate ranges up front and report). */
+export declare function satisfiesRange(version: string, range: string | undefined): boolean;

package/dist/semver.js

@@ -0,0 +1,129 @@
+// Minimal SemVer range matching, zero-dep — for plugin manifests' `engine` /
+// `editor` compatibility ranges and `dependencies`. Deliberately a SUBSET of node-semver:
+//   `*` / '' / undefined      any version
+//   `1.2.3`                   exact; a partial (`1.2`, `1`) is a wildcard tail
+//   `^1.2.3` / `~1.2.3`       caret / tilde (partials allowed: `^0.15`)
+//   `>=1.2 <2` `>1` `<=2.0.0` comparators, space-separated = AND
+//   `a || b`                  alternatives = OR
+// Prerelease tags order lexically below the bare triple (`1.0.0-beta < 1.0.0`).
+// The engine mirrors this file verbatim (it holds no runtime dependency on
+// core); the core↔engine contract test pins the two copies equal.
+const VERSION_RE = /^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+/** Parse `x.y.z[-pre]`; missing minor / patch read as 0. null when malformed. */
+export function parseSemVer(v) {
+    const m = VERSION_RE.exec(v.trim());
+    if (!m)
+        return null;
+    return { major: Number(m[1]), minor: Number(m[2] ?? 0), patch: Number(m[3] ?? 0), pre: m[4] };
+}
+/** Standard ordering: numeric triple, then a prerelease sorts BELOW its release. */
+export function compareSemVer(a, b) {
+    if (a.major !== b.major)
+        return a.major - b.major;
+    if (a.minor !== b.minor)
+        return a.minor - b.minor;
+    if (a.patch !== b.patch)
+        return a.patch - b.patch;
+    if (a.pre === b.pre)
+        return 0;
+    if (a.pre === undefined)
+        return 1;
+    if (b.pre === undefined)
+        return -1;
+    return a.pre < b.pre ? -1 : 1;
+}
+/** How many parts a partial version spelled out (`1` → 1, `1.2` → 2, `1.2.3` → 3). */
+function partsOf(s) {
+    const bare = s.replace(/^v/, '').split('-')[0];
+    return bare.split('.').length;
+}
+/** Expand one range token into comparators. null = malformed token. */
+function tokenToComparators(tok) {
+    if (tok === '*' || tok === 'x' || tok === 'X')
+        return [];
+    const m = /^(>=|<=|>|<|=|\^|~)?(.+)$/.exec(tok);
+    if (!m)
+        return null;
+    const op = m[1] ?? '';
+    const raw = m[2];
+    const v = parseSemVer(raw);
+    if (!v)
+        return null;
+    const n = partsOf(raw);
+    const nextMajor = { major: v.major + 1, minor: 0, patch: 0 };
+    const nextMinor = { major: v.major, minor: v.minor + 1, patch: 0 };
+    const nextPatch = { major: v.major, minor: v.minor, patch: v.patch + 1 };
+    switch (op) {
+        case '>=':
+        case '>':
+        case '<=':
+        case '<':
+            return [{ op, v }];
+        case '^':
+            if (v.major > 0 || n === 1)
+                return [{ op: '>=', v }, { op: '<', v: nextMajor }];
+            if (v.minor > 0 || n === 2)
+                return [{ op: '>=', v }, { op: '<', v: nextMinor }];
+            return [{ op: '>=', v }, { op: '<', v: nextPatch }];
+        case '~':
+            if (n === 1)
+                return [{ op: '>=', v }, { op: '<', v: nextMajor }];
+            return [{ op: '>=', v }, { op: '<', v: nextMinor }];
+        case '=':
+        case '':
+            if (n === 1)
+                return [{ op: '>=', v }, { op: '<', v: nextMajor }];
+            if (n === 2)
+                return [{ op: '>=', v }, { op: '<', v: nextMinor }];
+            return [{ op: '=', v }];
+    }
+    return null;
+}
+function test(c, v) {
+    const d = compareSemVer(v, c.v);
+    switch (c.op) {
+        case '>=':
+            return d >= 0;
+        case '>':
+            return d > 0;
+        case '<=':
+            return d <= 0;
+        case '<':
+            return d < 0;
+        case '=':
+            return d === 0;
+    }
+}
+/** Is `range` well-formed in this subset? (Empty / `*` count as valid.) */
+export function isValidRange(range) {
+    if (range === undefined || range.trim() === '')
+        return true;
+    return range.split('||').every((clause) => {
+        const toks = clause.trim().split(/\s+/).filter(Boolean);
+        if (!toks.length)
+            return false;
+        return toks.every((t) => tokenToComparators(t) !== null);
+    });
+}
+/** Does `version` satisfy `range`? A malformed version never does; a malformed
+ *  range never matches either (callers validate ranges up front and report). */
+export function satisfiesRange(version, range) {
+    if (range === undefined || range.trim() === '' || range.trim() === '*')
+        return parseSemVer(version) !== null;
+    const v = parseSemVer(version);
+    if (!v)
+        return false;
+    return range.split('||').some((clause) => {
+        const toks = clause.trim().split(/\s+/).filter(Boolean);
+        if (!toks.length)
+            return false;
+        const cmps = [];
+        for (const t of toks) {
+            const c = tokenToComparators(t);
+            if (c === null)
+                return false;
+            cmps.push(...c);
+        }
+        return cmps.every((c) => test(c, v));
+    });
+}

package/dist/serialize.d.ts

@@ -0,0 +1,63 @@
+import type { Lang, Project } from './ir.js';
+import type { CommandSchema } from './schema.js';
+export interface SerializeOptions {
+    /** Which catalog to read text from; defaults to project.meta.defaultLang. */
+    lang?: Lang;
+    /** Command schema registry: built-ins + the plugin commands the host knows
+     *  (`commandRegistry(manifests)`). Defaults to the built-ins only — a plugin
+     *  command absent from the registry serializes all-named, which the engine's
+     *  positional reads would drop, so a host that serializes plugin commands
+     *  must pass its registry. */
+    commands?: Record<string, CommandSchema>;
+    /** Emit `[label anchorLabel]` immediately before this node id (preview-from-here). */
+    anchorNodeId?: string;
+    /** Label name to inject at anchorNodeId; defaults to `__nilvn_here__`. */
+    anchorLabel?: string;
+    /** Emit `@key` references instead of resolved literal text, so the engine
+     *  resolves them at runtime from its catalogs (enables in-game language
+     *  switching). The engine ships every language's catalog alongside this DSL. */
+    keepKeys?: boolean;
+    /** Restrict serialization to these scene ids (in project order; unknown ids
+     *  are ignored). Omitted = the whole project. The scoped output is the unit a
+     *  future chunked/streaming export emits;
+     *  full export is just the no-scope degenerate case of the same code path.
+     *  NOTE: a scoped body may contain jumps to labels defined in OTHER scenes —
+     *  resolved when the full product loads; preview must degrade such a jump
+     *  gracefully rather than treat it as a parse error. */
+    scenes?: string[];
+    /** Chunked-export scoping: keep jump/choice targets that point at OTHER project
+     *  scenes (they're cross-chunk jumps the runtime resolves via the manifest
+     *  labelIndex), redirecting only genuinely-unconnected targets to the unset
+     *  landing. Default (a scoped PREVIEW) redirects every out-of-scope target,
+     *  since it can't play beyond the scope. Only meaningful with `scenes`. */
+    crossChunk?: boolean;
+}
+/** A serialized scope: the playable DSL plus the metadata a chunked export needs
+ *  to emit. Full export = serializeChunk with no
+ *  `scenes` scope (one chunk), so full and chunked share this one code path. */
+export interface SerializedChunk {
+    /** The `.nvn` DSL for the scope (what the engine parser consumes). */
+    body: string;
+    /** Jump-target labels this scope DEFINES: scene ids + in-scene `label` nodes.
+     *  The synthetic anchor/unset landing labels are excluded — they're preview-
+     *  only / per-chunk-local, not cross-chunk targets. Feeds the export manifest's
+     *  `labelIndex`. */
+    labels: string[];
+    /** Asset refs this scope references: per-scene command params + per-line voice.
+     *  Project-level shared assets (declared resources, actor face sprites) are NOT
+     *  scene-scoped and belong to the always-warm base, so they're not collected
+     *  here. */
+    assetRefs: string[];
+}
+export declare function serializeChunk(project: Project, opts?: SerializeOptions): SerializedChunk;
+/** Serialize to the `.nvn` DSL string (the common case: preview / interchange
+ *  export). Thin wrapper over serializeChunk, so the scoped and full paths are
+ *  identical and a caller that only wants the script stays unchanged. */
+export declare function serializeProject(project: Project, opts?: SerializeOptions): string;
+/** True when a value looks like an asset reference — used to pick asset paths out
+ *  of arbitrary command params. Zero-dep, so it's the single shared predicate. */
+export declare function isAssetRef(v: unknown): v is string;
+/** Label prefix for A–B replay segment start anchors (`__replay_<segId>`). Shared
+ *  with the engine's `playReplay` (which starts at this label) via the wire form
+ *  the `[replaydef]` preamble carries — the engine never re-derives it. */
+export declare const REPLAY_LABEL_PREFIX = "__replay_";