@hypit/hypit 0.1.14 → 0.2.0

package/packages/provider-whisperx-local/src/activation.ts

@@ -1,3 +1,4 @@
+import { resolve } from "node:path";
 import {
   createRuntimeEndpointAdapterFacet,
   runtimeConfigExact,
@@ -18,7 +19,7 @@ const localWhisperXRuntimeAdapter = createRuntimeEndpointAdapterFacet({
       "baseUrl", "expectedModel", "expectedDevice", "expectedCompute", "expectedBatchSize",
       "expectedServiceVersion", "expectedWhisperXVersion",
       "defaultConcurrency", "requestTimeoutMs", "maxResponseBytes",
-      "serviceCommand",
+      "serviceCommand", "alignmentLanguages", "modelCacheDirectory",
     ], "local WhisperX");
     const baseUrl = runtimeConfigString(config.baseUrl, "WhisperX baseUrl");
     if (baseUrl !== undefined) {
@@ -37,6 +38,12 @@ const localWhisperXRuntimeAdapter = createRuntimeEndpointAdapterFacet({
     const defaultConcurrency = runtimeConfigPositiveInteger(config.defaultConcurrency, "WhisperX defaultConcurrency");
     const requestTimeoutMs = runtimeConfigPositiveInteger(config.requestTimeoutMs, "WhisperX requestTimeoutMs");
     const maxResponseBytes = runtimeConfigPositiveInteger(config.maxResponseBytes, "WhisperX maxResponseBytes");
+    const modelCacheDirectory = runtimeConfigString(config.modelCacheDirectory, "WhisperX modelCacheDirectory");
+    const alignmentLanguages = config.alignmentLanguages;
+    if (alignmentLanguages !== undefined && (!Array.isArray(alignmentLanguages)
+      || alignmentLanguages.some((item) => typeof item !== "string" || !/^[a-z]+$/u.test(item)))) {
+      throw new Error("WhisperX alignmentLanguages must be an array of lowercase language codes");
+    }
     const serviceCommandValue = config.serviceCommand;
     if (serviceCommandValue !== undefined
       && (!Array.isArray(serviceCommandValue) || serviceCommandValue.length === 0
@@ -80,6 +87,8 @@ const localWhisperXRuntimeAdapter = createRuntimeEndpointAdapterFacet({
         expectedServiceVersion: selectedServiceVersion,
         expectedWhisperXVersion: selectedWhisperXVersion,
         ...(serviceCommand === undefined ? {} : { serviceCommand }),
+        ...(alignmentLanguages === undefined ? {} : { alignmentLanguages: alignmentLanguages as string[] }),
+        ...(modelCacheDirectory === undefined ? {} : { modelCacheDirectory: resolve(context.dataRoot, modelCacheDirectory) }),
       }),
     };
   },

package/packages/provider-whisperx-local/src/program.ts

@@ -52,6 +52,8 @@ export type LocalWhisperXProgramOptions = {
   readonly expectedServiceVersion: string;
   readonly expectedWhisperXVersion: string;
   readonly serviceCommand?: ManagedProgramCommand;
+  readonly alignmentLanguages?: readonly string[];
+  readonly modelCacheDirectory?: string;
 };
 
 export function localWhisperXProgram(options: LocalWhisperXProgramOptions): ManagedProgram {
@@ -85,11 +87,13 @@ export function localWhisperXProgram(options: LocalWhisperXProgramOptions): Mana
     HYPIT_WHISPERX_COMPUTE: expected.compute,
     HYPIT_WHISPERX_BATCH_SIZE: String(expected.batchSize),
     HYPIT_WHISPERX_NLTK_DATA: nltkData,
+    ...(options.modelCacheDirectory === undefined ? {} : { HYPIT_WHISPERX_MODEL_CACHE: options.modelCacheDirectory }),
+    HYPIT_WHISPERX_ALIGNMENT_LANGUAGES: (options.alignmentLanguages ?? []).join(" "),
   };
   const check: ManagedProgramCommand = {
     command: pythonEnvironmentCommand(environment, "hypit-whisperx-check"),
-    args: [],
-    env: { HYPIT_WHISPERX_NLTK_DATA: nltkData },
+    args: ["--models"],
+    env: serviceEnvironment,
   };
   const managedStart: ManagedProgramCommand = {
     command: pythonEnvironmentCommand(environment, "hypit-whisperx-service"),
@@ -131,10 +135,10 @@ export function localWhisperXProgram(options: LocalWhisperXProgramOptions): Mana
           args: ["sync", "--project", localWhisperXManagedProject, "--frozen", "--no-editable"],
           env: { UV_PROJECT_ENVIRONMENT: environment },
         }, {
-          label: "Prepare NLTK sentence data",
+          label: `Prepare WhisperX ${expected.model} and alignment resources for ${(options.alignmentLanguages ?? []).join(", ") || "no selected languages"}`,
           command: pythonEnvironmentCommand(environment, "hypit-whisperx-prepare"),
           args: ["--nltk-data", nltkData],
-          env: { HYPIT_WHISPERX_NLTK_DATA: nltkData },
+          env: serviceEnvironment,
         }],
       },
     } : {}),

package/packages/runtime-host-node/src/index.ts

@@ -245,6 +245,7 @@ export type RuntimeController = {
     down(options?: { readonly maxWaitMs?: number }): Promise<RuntimeWorkerState>;
   };
   readonly programs: {
+    prepare(options?: { readonly endpoints?: readonly string[]; readonly onProgress?: (event: ManagedProgramProgress) => void }): Promise<{ readonly dataRoot: string; readonly programs: readonly ManagedProgramReport[] }>;
     up(options: {
       readonly maxWaitMs?: number;
       readonly onProgress?: (event: ManagedProgramProgress) => void;

package/packages/runtime-kit/README.md

@@ -43,8 +43,12 @@ video package by name.
 
 `ManagedProgram.installation.prepareBeforeStart` lets a Provider reconcile its installed environment
 before a cold start, even when the installation probe already passes. The declared commands use the
-Provider's ordinary package manager. A healthy running Program is reused before this preparation is
-considered; Runtime does not inspect source files or infer implementation versions.
+Provider's ordinary package manager. `programs prepare` runs the declared installation independently
+of process startup; `programs up` also checks its resources when the process is already healthy.
+The installation probe covers the owner's selected execution resources, while the process probe
+reports service readiness. Cold reconciliation still applies only before starting a new process.
+Runtime does not name models, inspect source files or infer implementation versions. Preparation
+may acquire resources; execution must consume already prepared resources and report what is missing.
 `ManagedProgramCommand.label` optionally names a command's purpose for progress and log headings.
 It is display text supplied by the Program owner, not a phase to persist or interpret. Runtime
 reports generic process/probe facts; the service itself owns domain-specific progress in its logs.

package/packages/runtime-kit/src/index.ts

@@ -42,11 +42,11 @@ export type ManagedProgramCommand = {
 };
 
 export type ManagedProgramInstallation = {
-  /** Truthful inspection of the installed program; no installer-owned receipt. */
+  /** Read-only inspection of the selected environment and resources; no downloads or receipts. */
   probe(): Promise<ManagedProgramState>;
   /** Reconcile an installed environment before a cold start, using its package manager's cache. */
   readonly prepareBeforeStart?: boolean;
-  /** Commands run when installation is missing, or before a cold start when requested above. */
+  /** Explicit preparation commands, run for missing resources or cold reconciliation above. */
   readonly commands: readonly ManagedProgramCommand[];
 };
 

package/packages/runtime-local/README.md

@@ -242,7 +242,12 @@ controller returned by `await host.controller()`, and calls `build(...)` on the
 `await host.createRuntime()`. There is one production process-lifecycle path.
 
 Managed Programs have independent lifetimes. A healthy WhisperX service keeps its model loaded;
-`prepareBeforeStart` reconciles a cold installation through uv's source-aware synchronization.
+`programs prepare --endpoint <instance>` prepares selected resources without starting or stopping
+that service. Its installation probe is independent of process health, so an online service does not
+hide a newly requested language model. `programs up` prepares missing resources and starts the service
+if needed. `prepareBeforeStart` additionally reconciles a cold installation through the package
+manager's source-aware synchronization. The Provider owns the resource choices and commands;
+Runtime only invokes them under the existing lifecycle lock.
 `runtime down` stops the coordinator and asks its executors to stop; Programs are stopped separately.
 Distribution changes and shell environment changes still concern the coordinator's bootstrap process.
 Inspect active work before restarting it. Environment-backed credentials use that inherited process

package/packages/runtime-local/src/host.ts

@@ -23,6 +23,7 @@ import {
 } from "./config.js";
 import {
   bringManagedProgramsUp,
+  prepareManagedPrograms,
   reportManagedPrograms,
   takeManagedProgramsDown,
 } from "./programs.js";
@@ -82,6 +83,7 @@ export async function openLocalRuntimeHost(
         ),
       },
       programs: {
+        prepare: async (programOptions) => await prepareManagedPrograms(profile, { ...programOptions, packageRoot, ...distribution }),
         up: async (programOptions) => await bringManagedProgramsUp(profile, { ...programOptions, packageRoot, ...distribution }),
         down: async (scope) => await takeManagedProgramsDown(profile, { ...scope, packageRoot, ...distribution }),
         report: async (scope) => await reportManagedPrograms(profile, { ...scope, packageRoot, ...distribution }),

package/packages/runtime-local/src/index.ts

@@ -28,6 +28,7 @@ export {
 } from "./config.js";
 export {
   bringManagedProgramsUp,
+  prepareManagedPrograms,
   reportManagedPrograms,
   takeManagedProgramsDown,
 } from "./programs.js";

package/packages/runtime-local/src/programs.ts

@@ -293,6 +293,8 @@ async function bringUpOwned(
   onProgress?.({ id: program.id, phase: "checking" });
   const initial = await program.probe();
   if (initial.state === "ready") {
+    const prepared = await prepareOwned(root, program, endpoint, onProgress);
+    if (prepared.state.state !== "ready") return prepared;
     onProgress?.({ id: program.id, phase: "ready" });
     return { ...base, action: "already-running", state: initial };
   }
@@ -306,6 +308,10 @@ async function bringUpOwned(
   const installLogPath = join(directory(root, program), "install.log");
   const existingPid = await readPid(root, program);
   if (existingPid !== undefined && processAlive(existingPid)) {
+    if (program.installation !== undefined) {
+      const prepared = await prepareOwned(root, program, endpoint, onProgress);
+      if (prepared.state.state !== "ready") return prepared;
+    }
     release();
     onProgress?.({ id: program.id, phase: "waiting", logPath,
       detail: `observing existing process ${existingPid}` });
@@ -320,23 +326,9 @@ async function bringUpOwned(
   }
   if (existingPid !== undefined) await rm(join(directory(root, program), "process.pid"), { force: true });
   if (program.installation !== undefined) {
-    const installation = await program.installation.probe();
-    if (installation.state !== "ready" || program.installation.prepareBeforeStart === true) {
-      await mkdir(directory(root, program), { recursive: true });
-      await rotateLog(installLogPath);
-      for (const command of program.installation.commands) {
-        onProgress?.({ id: program.id, phase: "installing", logPath: installLogPath, detail: commandLabel(command) });
-        const result = await run(root, command, installLogPath);
-        if (!result.ok) {
-          return { ...base, action: "unchanged", state: initial, logPath: installLogPath, detail: `${command.command} failed: ${result.detail}` };
-        }
-      }
-      const after = await program.installation.probe();
-      if (after.state !== "ready") {
-        return { ...base, action: "unchanged", state: initial, logPath: installLogPath, detail: `installation is ${after.state}: ${after.detail}` };
-      }
-      installed = true;
-    }
+    const prepared = await prepareOwned(root, program, endpoint, onProgress, program.installation.prepareBeforeStart === true);
+    if (prepared.state.state !== "ready") return prepared;
+    installed = prepared.action === "installed";
   }
   if (program.start === undefined) {
     // Nothing to keep running: installation was the whole job.
@@ -435,6 +427,50 @@ async function bringUp(
   } finally { release(); }
 }
 
+/** Resource preparation is independent of process readiness. Caller owns the lifecycle lock. */
+async function prepareOwned(
+  root: string, program: ManagedProgram, endpoint: string,
+  onProgress?: (event: ManagedProgramProgress) => void, reconcile = false,
+): Promise<ManagedProgramReport> {
+  const base = { id: program.id, endpoint };
+  const installation = program.installation;
+  if (installation === undefined) return { ...base, action: "unchanged", state: await program.probe() };
+  const logPath = join(directory(root, program), "install.log");
+  const before = await installation.probe();
+  if (before.state === "ready" && !reconcile) return { ...base, action: "unchanged", state: before };
+  await mkdir(root, { recursive: true });
+  await rotateLog(logPath);
+  for (const command of installation.commands) {
+    onProgress?.({ id: program.id, phase: "installing", logPath, detail: commandLabel(command) });
+    const result = await run(root, command, logPath);
+    if (!result.ok) return { ...base, action: "unchanged", state: { state: "down", detail: `${command.command} failed: ${result.detail}` }, installationLogPath: logPath };
+  }
+  const state = await installation.probe();
+  return { ...base, action: state.state === "ready" ? "installed" : "unchanged", state, installationLogPath: logPath };
+}
+
+/** Prepare selected resources without starting, stopping or trusting a running process. */
+export async function prepareManagedPrograms(
+  path: string, options: ManagedProgramOptions = {},
+): Promise<{ readonly dataRoot: string; readonly programs: readonly ManagedProgramReport[] }> {
+  const { dataRoot, programs } = await declaredManagedPrograms(path, options);
+  const reports = await Promise.all(independentPrograms(programs).map(async ({ instance, program }): Promise<ManagedProgramReport> => {
+    const home = directory(dataRoot, program);
+    await mkdir(home, { recursive: true });
+    const { tryProgramLock } = await import("./program-lock.js");
+    const release = tryProgramLock(home);
+    if (release === undefined) return { id: program.id, endpoint: instance, action: "unchanged", state: { state: "down", detail: "another command owns this Program's preparation; inspect its logs" } };
+    try {
+      options.onProgress?.({ id: program.id, phase: "checking" });
+      const report = await prepareOwned(dataRoot, program, instance, options.onProgress);
+      if (report.state.state === "ready") options.onProgress?.({ id: program.id, phase: "ready" });
+      return report;
+    }
+    finally { release(); }
+  }));
+  return { dataRoot, programs: reports };
+}
+
 /** Install when needed and start every external program the Runtime Profile implies. */
 export async function bringManagedProgramsUp(
   path: string,

package/packages/script/README.md

@@ -10,7 +10,7 @@ know that Script, Segment or Narrative exist.
 
 ```svml
 <script id="story">
-  @answer
+  @{answer}
 
   <opening>
     <ALICE> I will make the first point.
@@ -18,7 +18,7 @@ know that Script, Segment or Narrative exist.
   </opening>
 
   <pause/>
-  @/answer
+  @{/answer}
 </script>
 ```
 
@@ -65,8 +65,8 @@ CaptionDocument contracts.
   Role Cue or the Segment close ends that turn.
 - **Dual Text**: one authored speech span with separate display and spoken projections, written
   `<display text | spoken text>`. In `<display text|>`, omitted speech inherits the displayed prose.
-- **Selection marker**: a named semantic range, written `@name ... @/name`.
-- **Moment marker**: a named semantic point, written `@name!`.
+- **Selection marker**: a named semantic range, written `@{name} ... @{/name}`.
+- **Moment marker**: a named semantic point, written `@{name!}`.
 - **CaptionDocument**: the Script-owned caption truth; it contains **Display Words**,
   **Alignment Units** and **Cue Breaks**. It contains no seconds or frames.
 - **Token attribute**: a flat postfix display-word annotation such as `really{emphasis}` or
@@ -86,7 +86,7 @@ Caption Styles choose whether to highlight, reveal or keep the text steady.
 
 In a shared side, markers and display attributes do not enter either text projection. Its speech
 Tokens retain offsets into the actually written left-hand text, so Studio can move an anchor inside
-`<组@beat!件化|>` without expanding the shorthand. Attributes still annotate the preceding display
+`<组@{beat!}件化|>` without expanding the shorthand. Attributes still annotate the preceding display
 word, not the whole group. Whitespace-only speech is omitted; a group with no spoken text on either
 side is invalid. This adds no new public value type or protocol version.
 
@@ -101,8 +101,8 @@ Units; it does not split the Segment, cut the picture or end a Selection.
 <script id="story">
   <exchange>
     <HOST> I use it || every day, || since <2012 | twenty twelve>.
-    <GUEST> Even @proof on holiday @/proof?
-    <HOST> @answer! Especially then.
+    <GUEST> Even @{proof} on holiday @{/proof}?
+    <HOST> @{answer!} Especially then.
   </exchange>
 </script>
 ```
@@ -117,19 +117,53 @@ following characters. Display punctuation attaches to neighboring words without
 These units support precise timing and highlighting. A Caption Cue can hold a whole phrase of them;
 `||` chooses its handoff independently of character counts or visual line wrapping.
 
+Annotations do not create speech boundaries. Comments are transparent (`hel<!--note-->lo`
+remains `hello`); a postfix attribute or `||` inside a word is invalid. Script analyzes a complete
+prose run before binding these constructs. An explicit Dual correspondence and a speaker/Segment
+boundary remain authored structure. Shared Dual groups still expose their internal speech anchors.
+
+A Dual display side is literal authored text, including symbols and emoji: `<😀|smile>` and
+`<.|dot>` have explicit speech correspondence and require no invented speech token for the symbol.
+A literal-only display is one display surface within that correspondence.
+
+## Display spelling and separators
+
+Script preserves the normalized display spelling independently of speech tokenization. Ordinary
+whitespace runs become one space; leading/trailing whitespace in a Turn and padding at the edges
+of a Dual Text side are omitted. No language-specific rule removes a Chinese space or inserts a
+space between numeric and Korean/Latin tokens. `是的 就是这样`, `3개월`, `3 개월`, `3D` and `3 D`
+therefore remain distinct as authored. Source newlines are prose formatting, not Caption Cue breaks.
+Use `||` for Cues and a family's layout controls for visual rows.
+
+Each `CaptionDisplayWord.separatorBefore` is `""` or `" "`, relative to the preceding displayed word
+in its Turn. Together with `text`, it carries the display spelling to consumers; it is not a speech
+Token and has no timing. A renderer suppresses the leading separator at a displayed line/Cue start.
+Shared groups retain internal separators and individual speech anchors: `<New York|>` is one
+Alignment Unit with a space inside, while `<3D|>` has none. Grouping is a creative choice, not a
+workaround for preserving spelling.
+
 ## Selection and Moment affinity
 
+Every marker starts with `@{` and ends with `}`. The complete marker is zero-width in speech and
+display; surrounding prose whitespace remains prose. All control sigils belong inside the braces:
+`@{beat!}` is a Moment, whereas `@{part}!` opens a Selection followed by a literal exclamation mark.
+Names match `[a-z][a-z0-9_-]{0,63}`; whitespace and nesting inside a marker are invalid.
+A marker cannot split a speech Token or separate it from attached punctuation: place
+`@{beat!}“测试”`, not `“@{beat!}测试”`. `hello{emphasis}` is a postfix display attribute; `@{part}`
+is consumed as one marker and cannot be mistaken for that attribute. Write a literal `@{part}` as
+`\@\{part\}`.
+
 A marker selects the adjacent semantic anchor; it does not write a timecode. Inside a spoken
 passage, its affinity normally chooses a neighboring word boundary:
 
 | Marker | Boundary |
 | --- | --- |
-| `@name` | Selection opens at the next word's start: right affinity. |
-| `~@name` | Selection opens at the previous word's end: left affinity. |
-| `@/name` | Selection closes at the previous word's end: left affinity. |
-| `@/name~` | Selection closes at the next word's start: right affinity. |
-| `@name!` | Moment at the next word's start: right affinity. |
-| `~@name!` | Moment at the previous word's end: left affinity. |
+| `@{name}` | Selection opens at the next word's start: right affinity. |
+| `@{~name}` | Selection opens at the previous word's end: left affinity. |
+| `@{/name}` | Selection closes at the previous word's end: left affinity. |
+| `@{/name~}` | Selection closes at the next word's start: right affinity. |
+| `@{name!}` | Moment at the next word's start: right affinity. |
+| `@{~name!}` | Moment at the previous word's end: left affinity. |
 
 At structural edges, the parser retains the corresponding Segment or program boundary rather than
 inventing a neighboring word. Selection and Moment ids share one namespace. Selections can overlap,
@@ -138,37 +172,50 @@ cross and span Segments; unlike tags, they do not need to nest.
 To join two visual Selections without exposing their inter-word pause, match affinity on both sides:
 
 ```text
-@coffee my coffee @/coffee ~@smoothie my smoothie @/smoothie
-@coffee my coffee @/coffee~ @smoothie my smoothie @/smoothie
+@{coffee} my coffee @{/coffee} @{~smoothie} my smoothie @{/smoothie}
+@{coffee} my coffee @{/coffee~} @{smoothie} my smoothie @{/smoothie}
 ```
 
 These are alternative spellings, not two occurrences to put in the same Script. In the first,
 “coffee” ends both the first Window and the gap's left boundary, so the smoothie Selection owns the
 pause. In the second, the next “my” starts both touching boundaries, so the coffee Selection owns it.
-Plain `@/coffee @smoothie` leaves the gap between previous word end and next word start outside both.
+Plain `@{/coffee} @{smoothie}` leaves the gap between previous word end and next word start outside both.
 The media consumer still decides playback and visual coverage inside those projected Windows.
 
 ## Marker writeback
 
 `adjustScriptSelection` and `adjustScriptMoment` accept explicit anchor identities. A Selection's
-two endpoints are written together. Script owns their legal source sites: token punctuation and
-postfix attributes stay attached, Segment boundaries stay structural, and coincident markers are
-ordered together. Writeback reads the current source, removes the markers, normalizes ordinary
-same-line prose, and places the markers at their requested anchors. Repeated spaces and tabs in
-prose become necessary separators; punctuation uses the same attachment rules as Script's text
-projection. Newlines, blank lines and each line's leading spaces/tabs remain intact. A marker at
-the start of a line is placed after its indentation; whitespace after that marker is prose, not
-additional indentation. Marker-only lines remain blank when the marker leaves. Comments, tags,
-Dual Text and display attributes retain their own syntax and are not passed through prose cleanup.
-
-Normalization keeps lexical units unchanged and does not restore earlier whitespace spellings.
-It has no persistent formatting state: the same text structure and anchor relationships produce
-the same spelling on repeated edits. Empty self-closing Segments expand when needed to make their
-distinct boundaries writable.
-
-Writeback reparses the result to retain the intended identities and unchanged narrative/caption
-content. These checks concern authored order, not frame order. A consumer's temporal projection
-determines whether the resulting Instant or Window is usable.
+two endpoints are moved together; unrelated markers and all source prose remain untouched. Names
+terminate at `}`, so writeback never inserts a separating space or normalizes surrounding prose.
+A no-op adjustment returns the original source. Script owns legal insertion sites: Tokens and
+postfix attributes stay together, Dual Text markers follow the actual speech side, and coincident
+markers written together have deterministic order. Empty self-closing Segments expand only when a
+requested boundary needs an interior insertion site.
+
+Writeback reparses the result to retain the requested bindings and unchanged speech, display and
+Narrative/Caption content. Source offsets remain parser-private; no formatting history is stored.
+
+## Explicit migration from 0.1
+
+The 0.2 parser rejects bare `@name` markers. Preview migration from the repository or installed
+Distribution root, then explicitly write the reviewed result:
+
+```sh
+node packages/script/bin/migrate-0.2.mjs /path/to/film.svml
+node packages/script/bin/migrate-0.2.mjs /path/to/film.svml --write
+```
+
+Use `--body` for a file containing a raw Script body rather than outer SVML. The tool converts
+markers only inside Script bodies, leaves comments and escapes intact, and does not touch provider
+prompt references such as `@image1`. It neither installs anything nor runs during a build.
+
+The tool changes marker spelling, not marker placement. Move a marker that separates a word from
+its attached quote or punctuation to the complete word boundary before using that source.
+
+Review authored whitespace after migration: spaces previously discarded by Chinese/punctuation
+normalization now appear. The tool preserves source spaces rather than guessing the author's intent.
+Regenerate affected Narrative, caption and Build results with the new reader/writer together;
+protocol identities remain `@1`. Existing rendered media is not modified by source migration.
 
 ## Complete authored content and narrow exports
 

package/packages/script/bin/migrate-0.2.mjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+/** Explicit, one-time marker migration. Never called by parsing, building, or Studio. */
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+export function migrateScriptBody(source) {
+  let result = "";
+  for (let cursor = 0; cursor < source.length;) {
+    if (source[cursor] === "\\") {
+      result += source.slice(cursor, cursor + 2);
+      cursor += 2;
+      continue;
+    }
+    if (source.startsWith("<!--", cursor)) {
+      const close = source.indexOf("-->", cursor + 4);
+      if (close < 0) throw new Error("Unclosed Script comment");
+      result += source.slice(cursor, close + 3);
+      cursor = close + 3;
+      continue;
+    }
+    if (source.startsWith("@{", cursor)) {
+      const close = source.indexOf("}", cursor + 2);
+      if (close < 0) throw new Error("Unclosed delimited Script marker");
+      result += source.slice(cursor, close + 1);
+      cursor = close + 1;
+      continue;
+    }
+    const rest = source.slice(cursor);
+    const match = /^@\/([a-z][a-z0-9_-]{0,63})(~)/u.exec(rest)
+      ?? /^@\/([a-z][a-z0-9_-]{0,63})(?![A-Za-z0-9_-])/u.exec(rest);
+    const open = match ? undefined : /^(~)?@([a-z][a-z0-9_-]{0,63})(!)/u.exec(rest)
+      ?? /^(~)?@([a-z][a-z0-9_-]{0,63})(?![A-Za-z0-9_-])/u.exec(rest);
+    if (match) {
+      result += `@{/${match[1]}${match[2] ?? ""}}`;
+      cursor += match[0].length;
+    } else if (open) {
+      result += `@{${open[1] ?? ""}${open[2]}${open[3] ?? ""}}`;
+      cursor += open[0].length;
+    } else {
+      result += source[cursor++];
+    }
+  }
+  return result;
+}
+
+/** Change Script raw bodies only; package references and generation prompt tags stay untouched. */
+export function migrateSvml(source) {
+  let result = "";
+  let cursor = 0;
+  const token = /<!--[\s\S]*?-->|<(?:[A-Za-z_][\w.-]*:)?script(?=[\s/>])(?:"[^"]*"|'[^']*'|[^'">])*>/gu;
+  for (let match = token.exec(source); match; match = token.exec(source)) {
+    if (match[0].startsWith("<!--") || match[0].endsWith("/>")) continue;
+    const name = /^<([^\s>]+)/u.exec(match[0])[1];
+    const close = `</${name}>`;
+    const start = match.index + match[0].length;
+    let end = start;
+    while (end < source.length) {
+      if (source[end] === "\\") { end += 2; continue; }
+      if (source.startsWith("<!--", end)) {
+        const stop = source.indexOf("-->", end + 4);
+        if (stop < 0) throw new Error("Unclosed Script comment");
+        end = stop + 3;
+        continue;
+      }
+      if (source.startsWith(close, end)) break;
+      end++;
+    }
+    if (end >= source.length) throw new Error(`Missing ${close}`);
+    result += source.slice(cursor, start) + migrateScriptBody(source.slice(start, end)) + close;
+    cursor = end + close.length;
+    token.lastIndex = cursor;
+  }
+  return result + source.slice(cursor);
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+  const args = process.argv.slice(2);
+  const flags = new Set(args.filter(arg => arg.startsWith("--")));
+  const paths = args.filter(arg => !arg.startsWith("--"));
+  if (paths.length !== 1 || [...flags].some(flag => !["--write", "--body"].includes(flag))) {
+    console.error("Usage: node migrate-0.2.mjs <source.svml> [--body] [--write]\nDefault: print migrated SVML. --body: input is a raw Script body. --write: replace the named file.");
+    process.exitCode = 2;
+  } else {
+    const source = await readFile(paths[0], "utf8");
+    const migrated = flags.has("--body") ? migrateScriptBody(source) : migrateSvml(source);
+    if (flags.has("--write")) await writeFile(paths[0], migrated);
+    else process.stdout.write(migrated);
+  }
+}