@patterkit/ops 0.13.0 → 0.14.0

package/dist/index.d.ts

@@ -244,11 +244,21 @@ interface ValidateResult {
     /** The game's shared scopes folder: its files, and how the project stands against them. Only the
      *  errors count against `ok`. Empty when the project has no folder. */
     gameScopes: GameScopesIssue[];
+    /** The loc shards against each other and the project: a key two shards give different text (an
+     *  error: the compile refuses it), and as warnings a shard for a scene the project lacks, one in a
+     *  language it does not declare, or two shards for one scene and language. */
+    localisation: GameScopesIssue[];
     /** Only ERRORS count: a warning (another tool's scope, say) never fails a build. */
     ok: boolean;
 }
 /** Run structural + expression + interpolation + hygiene + bundle-staleness + merge validation. */
 declare function runValidate(loaded: LoadedProject): ValidateResult;
+/**
+ * The content errors a bundle may not be built over, one line each: structural errors (not warnings),
+ * condition and interpolation errors, and loc shards that disagree. Not hygiene, staleness, orphans or
+ * reachability: those say nothing about whether the bundle works. `runExport` refuses on these.
+ */
+declare function exportBlockers(loaded: LoadedProject): string[];
 
 /**
  * Conditions that can never hold, as warnings. Empty for a project with no monotonic latches, which is
@@ -256,17 +266,122 @@ declare function runValidate(loaded: LoadedProject): ValidateResult;
  */
 declare function reachabilityIssues(loaded: LoadedProject, compiled?: Bundle): ConditionIssue[];
 
-declare function runExport(loaded: LoadedProject): Bundle;
+/** A recording ladder rung as the indexer needs it: a name and its (optional) project-relative folder. */
+interface AudioRung {
+    name: string;
+    folder?: string;
+}
+/** One resolved beat: the rung it landed in, the absolute path to its audio file, and (for scratch takes)
+ *  the text-hash stamped in the WAV so the editor can flag a take that's gone stale against its line. */
+interface AudioEntry {
+    status: string;
+    path: string;
+    textHash?: string;
+}
+/** beatId -> resolved audio. Absent ids are implicitly "missing". */
+type AudioSnapshot = Record<string, AudioEntry>;
+/** The sidecar audio manifest (`patteraudio.json`): each beat's winning clip, keyed by beatId, with its
+ *  path relative to the audio root (forward-slashed) + the rung it resolved to. Consumed by the runtimes'
+ *  audio resolvers. Kept OUT of the .patterc so audio stays decoupled from story rebuilds. */
+declare const AUDIO_MANIFEST_SCHEMA = "patter/audio@0";
+declare const AUDIO_MANIFEST_FILE = "patteraudio.json";
+/** Whether a project derives recording status from folders at all: voiced, tracking audio status, Audio
+ *  Folders on, and an audio root set. */
+declare function audioFoldersActive(p: ProjectFile): boolean;
+/** The ladder's rungs that have a folder, HIGHEST priority first (the most-finished take wins), with each
+ *  folder made absolute against the project root. */
+declare function audioFolderRungs(root: string, rungs: AudioRung[]): Array<{
+    name: string;
+    dir: string;
+}>;
+/** The snapshot from each rung folder's listing, highest rung first (`undefined` files = a folder that is
+ *  missing or unreadable, treated as empty). Within a folder a `.wav` beats an `.mp3` of the same id; a
+ *  higher rung that already claimed an id wins overall. */
+declare function pickAudio(listings: Array<{
+    name: string;
+    dir: string;
+    files: string[] | undefined;
+}>): AudioSnapshot;
+/** One synchronous scan of a project's audio folders, or undefined when it does not use them. */
+declare function scanAudio(loaded: LoadedProject): AudioSnapshot | undefined;
+/** beatId -> derived recording status, for the report and the voice script; undefined when the project
+ *  doesn't derive status from folders, so callers fall back to the manual recording map as Patterpad does. */
+declare function scanAudioStatus(loaded: LoadedProject): Map<string, string> | undefined;
+/** Serialise a snapshot into the sidecar manifest JSON, with each absolute path made root-relative
+ *  (forward-slashed) against `<projectRoot>/<audioRoot>`. */
+declare function audioManifest(snapshot: AudioSnapshot, projectRoot: string, audioRoot: string): string;
+/** The manifest write for a snapshot, beside the audio; undefined when the project does not use Audio
+ *  Folders or no take has been found yet. */
+declare function audioManifestWrite(loaded: LoadedProject, snapshot: AudioSnapshot | undefined): PlannedWrite | undefined;
+
+/** What a shipped build may not be built over. */
+interface ExportOptions {
+    /** Build even when validate finds errors in the content (a dangling jump, a condition that does not
+     *  parse): the CLI's `--allow-invalid`. Never what a game wants; for looking at a broken build. */
+    allowInvalid?: boolean;
+}
+/** Compile a loaded project to the runtime bundle, applying its build localisation mode (spec §11):
+ *  "embedded" (default) keeps every locale's strings inline; "ids" strips them so the runtime emits beat
+ *  IDs (the game localises). `sourceDebug` keeps only the SOURCE locale, embedded for debug playback and
+ *  flagged so the runtime warns it is not a shippable build. Refuses an unresolved merge, and content
+ *  validate calls broken unless `allowInvalid`. */
+declare function runExport(loaded: LoadedProject, opts?: ExportOptions): Bundle;
 /** Compile WITHOUT the localisation-mode transform - the full bundle with every locale inline. Used where
- *  the host needs all strings regardless of build mode (e.g. Patterpad's Play window + Export Localisation). */
-declare function runExportFull(loaded: LoadedProject): Bundle;
+ *  the host needs all strings regardless of build mode (e.g. Patterpad's Play window + Export Localisation).
+ *  Refuses an unresolved merge; broken content only with `refuseInvalid: true` (the playable page), since
+ *  the Play window exists to try content mid-edit. */
+declare function runExportFull(loaded: LoadedProject, opts?: ExportOptions & {
+    refuseInvalid?: boolean;
+}): Bundle;
+/** Everything a build writes, for a front end to commit. */
+interface BuildPlan {
+    bundle: Bundle;
+    /** The bundle as written: strict JSON, since every runtime reads it with a stock parser. */
+    text: string;
+    /** The bundle, `patter.scopes.json` when the game's scopes folder needs it brought up to date, and the
+     *  audio manifest when the project uses Audio Folders and has takes. The bundle first. */
+    writes: PlannedWrite[];
+}
+/**
+ * Plan a build: the bundle and everything that goes with it, so every front end writes the same set
+ * (CLI review 2026-10, item 23). Patterpad's Build wrote bundle, scopes and audio manifest; its Auto
+ * Rebuild skipped the scopes file; `patter export` never wrote the manifest. `bundlePath` overrides
+ * where the bundle goes (the CLI's `-o`); `audio` is a snapshot the caller already holds (Patterpad's
+ * live index), else the folders are scanned now.
+ */
+declare function planBuild(loaded: LoadedProject, opts?: ExportOptions & {
+    bundlePath?: string;
+    audio?: AudioSnapshot;
+}): BuildPlan;
+
+/**
+ * Compile a loaded project exactly as `export` does, with nothing refused: the one compile every analysis
+ * uses (validate's staleness check, reachability, play, coverage). Five sites each compiled the project
+ * themselves and had drifted from export: none stripped the contentless beats export strips, so one blank
+ * line made a freshly exported bundle read as stale for ever, and coverage counted beats that never ship.
+ */
+declare function compileLoaded(loaded: LoadedProject): Bundle;
 /**
- * The conventional output path for the compiled `.patterc` bundle (spec §11):
- * the project's `export.bundle` (relative to the root, or absolute) if set,
- * else `dist/<project-file-stem>.patterc`. This is where `patter export` writes
- * with no `-o`, and a stable place the staleness gate (validate) can find.
+ * The default bundle location, relative to the project root, used when the project pins no
+ * `export.bundle`: a SIBLING `patter-dist/` folder, not inside the project. On macOS the project folder is
+ * a `.patter` package, and build output buried in the document is output nobody finds. One default for
+ * every front end: the CLI wrote `dist/` inside the project while Patterpad wrote beside it, so a project
+ * built in both had two bundles, and validate's staleness check never saw Patterpad's.
+ */
+declare function defaultBundlePath(loaded: LoadedProject): string;
+/**
+ * The output path for the compiled bundle (spec §11): the project's `export.bundle` (relative to the
+ * root, or absolute) if set, else `defaultBundlePath`. Where `patter export` and Patterpad's Build Bundle
+ * write, and where validate's staleness check looks.
  */
 declare function bundleOutputPath(loaded: LoadedProject): string;
+/**
+ * A file exported beside the bundle (the playable page, the screenplay): the bundle's path with `ext` in
+ * place of its extension, whatever that is. Only a `.patterc` ending was ever swapped, so a bundle pinned
+ * as `build/game.json` (what a Unity TextAsset wants) was overwritten by the HTML. Throws when the result
+ * would be the bundle itself.
+ */
+declare function besideBundlePath(loaded: LoadedProject, ext: string): string;
 
 /** Build a single self-contained playable HTML document for the loaded project. Pure: returns the file's
  *  text; the caller writes it. One file to email anyone; it plays offline in any browser. */
@@ -287,8 +402,6 @@ interface WebExport {
 }
 declare function runExportWeb(loaded: LoadedProject): WebExport;
 
-declare function scanAudioStatus(loaded: LoadedProject): Map<string, string> | undefined;
-
 interface PlayOptions {
     /** Scene id to start at (defaults to the bundle's first scene). */
     scene?: string;
@@ -327,9 +440,18 @@ type PlayEvent = {
  | {
     type: "error";
     error: PlayError;
+}
+/** The run could not go on, and this is why: the engine stopped (a jump cycle with nothing to deliver,
+ *  a jump to a target the bundle lacks), or a scripted choice named an option the choice did not offer.
+ *  Always the last event, and the outcome is then "error". */
+ | {
+    type: "error";
+    fatal: true;
+    message: string;
 };
-/** "end" = the flow finished; "stalled" = a choice with no pickable option; "max-steps" = bound hit. */
-type PlayOutcome = "end" | "stalled" | "max-steps";
+/** "end" = the flow finished; "max-steps" = bound hit; "error" = the run stopped, and the last event says
+ *  why. (There is no "stalled": a choice with nothing to pick runs dry and play moves on.) */
+type PlayOutcome = "end" | "max-steps" | "error";
 interface PlayResult {
     events: PlayEvent[];
     outcome: PlayOutcome;
@@ -339,6 +461,11 @@ interface PlayResult {
  * runtime. At each choice point it consumes the next scripted choice id, else
  * picks the first eligible option - so it always runs to an outcome. The whole
  * pipeline in one call: load -> export -> Engine playthrough.
+ *
+ * A run the engine stops part-way still returns its transcript: the throw is
+ * caught and becomes the last event, with outcome "error". It used to escape,
+ * so a playthrough that went wrong lost everything that led up to it, which is
+ * exactly what the author needs to see.
  */
 declare function runPlay(loaded: LoadedProject, opts?: PlayOptions): PlayResult;
 /** Render a play result as the CLI's readable transcript lines. */
@@ -385,7 +512,10 @@ interface CoverageBeat {
      *  (one of several random picks is rare by design). Absent on a never-reached beat. */
     rare?: true;
     /** Set on a never-reached beat that is gated on a host-scope ref (`@world.x`) nothing writes and no
-     *  driver provides, i.e. it may just need an input, not be truly dead. Lists the offending refs. */
+     *  driver provides, i.e. it may just need an input, not be truly dead. Lists the offending refs. The
+     *  gate is the beat's own conditions and its ancestors', plus any ref that every jump into its block
+     *  passes (a block reached only past a gated jump is gated too). Absent on a beat a branch sibling
+     *  before it always wins over: no input can help that one. */
     needsInput?: string[];
     /** Set on a never-reached beat gated on a ref that IS written, but ONLY by content that was itself
      *  never reached: the beat is dead at one remove, and the gate is not the real question. Names the
@@ -398,8 +528,13 @@ interface BlockedGate {
     /** The gating ref, at the granularity the condition reads it: `@world.alarm`, or `@world.mood:armed`
      *  for a single flag of a flags property. */
     ref: string;
-    /** Beat ids witnessing the writers: content that would have to play for this gate to be written. */
+    /** The writers: content that would have to run for this gate to be written. A writer with beats of its
+     *  own is named by its beats; one without (a scene's entry effects, a snippet that only jumps, an option
+     *  with only a prompt) by its own node id. */
     writers: string[];
+    /** The gate is on the way INTO the beat's block (a jump or call taken only past it), not on the beat
+     *  itself: the place to look is the jump. */
+    onTheWayIn?: true;
 }
 /** A choice that ran DRY during the coverage run: at some point it had no takeable option and no eligible
  *  fallback, so it fell through silently and the flow carried on past it. This is easy to author by
@@ -408,9 +543,11 @@ interface BlockedGate {
 /** A condition or effect that failed during the runs. The engine plays through these (a failing condition
  *  counts as false, a failing effect is skipped), so without this list they would pass unseen. */
 interface ContentError {
-    /** What failed: a condition, an effect, or a part of a condition scored for Best match. */
-    kind: PlayError["kind"];
-    /** The snippet, group, or option whose condition failed, or the snippet or scene owning the effect. */
+    /** What failed: a condition, an effect, or a part of a condition scored for Best match; or "stopped",
+     *  when the engine threw and the run ended there (a jump cycle with nothing to deliver). */
+    kind: PlayError["kind"] | "stopped";
+    /** The snippet, group, or option whose condition failed, or the snippet or scene owning the effect. For
+     *  "stopped", the scene the run was in when it stopped. */
     node: string;
     /** The scene the node lives in. */
     scene: string;
@@ -448,7 +585,9 @@ interface CoverageReport {
     };
     /** The reach % below which a reached beat counts as rare ({@link RARE_REACH_PCT}). */
     rareThresholdPct: number;
-    /** How each run ended, for the summary header. */
+    /** How each run ended, for the summary header. `evalError` counts the runs the engine stopped, each
+     *  with its cause in `contentErrors` (kind "stopped"). `stalled` is always 0 now (a choice with nothing
+     *  to pick runs dry and play moves on), and stays only because Patterpad's Coverage window reads it. */
     termination: {
         ended: number;
         capped: number;
@@ -515,7 +654,9 @@ declare function renderCoverageText(report: CoverageReport, sceneName?: (id: str
 }): string[];
 
 /** Resolve where a flow starts: an explicit override, else the project's authored `start`, else `{}`
- *  (the runtime's first-scene default). Shared by `runPlay` and `runCoverage`. */
+ *  (the runtime's first-scene default). Shared by `runPlay` and `runCoverage`. A block named with no scene
+ *  is looked for in every scene (see `findBlockAnywhere`), so it is never silently dropped for the
+ *  project's own start; that search throws when the block is in no scene, or in more than one. */
 declare function resolveStart(loaded: LoadedProject, override?: {
     scene?: string;
     block?: string;
@@ -529,9 +670,11 @@ interface FormatResult {
     changed: boolean;
     /** The canonical content to commit - present only when `changed`. */
     write?: PlannedWrite;
+    /** Not Patter source (not a shard by its extension), so left alone. */
+    skipped?: boolean;
 }
 /** Compute the canonical form of each file. Returns planned writes; writes nothing. */
-declare function runFormat(files: string[]): FormatResult[];
+declare function runFormat(paths: string[]): FormatResult[];
 
 /** Counts for the WRITTEN population (line + text + label beats). */
 interface WrittenCounts {
@@ -678,7 +821,8 @@ declare function extractLoc(loaded: LoadedProject, opts?: {
     locale?: string;
 }): LocCatalog;
 /**
- * Write a catalog's translations back. Produces the loc-shard writes (one per scene touched) and stamps
+ * Write a catalog's translations back. Throws, writing nothing, when the catalogue names a locale the
+ * project does not declare or a scene it does not have. Produces the loc-shard writes (one per scene touched) and stamps
  * `localisedAt[locale]` into the per-scene authoring shards (skipped when importing the default locale -
  * staleness is tracked against the source, not for it). Caller commits the returned writes.
  *
@@ -704,8 +848,9 @@ declare function poToCatalog(text: string): LocCatalog;
 
 /** Render the catalog as an .xlsx workbook: a sheet per scene, translator-facing columns. */
 declare function catalogToXlsx(catalog: LocCatalog): Promise<Buffer>;
-/** Parse an .xlsx workbook back into a catalog. Scene = sheet name; stale = Status "stale". `locale` is
- *  not carried in the sheet, so the caller supplies it (--locale). */
+/** Parse an .xlsx workbook back into a catalog. Scene = the hidden Scene column (else, for an older export,
+ *  the sheet name); stale = Status "stale". `locale` is not carried in the sheet, so the caller supplies it
+ *  (--locale). Throws when a scene is not a plain scene id (see `checkCatalogField`). */
 declare function xlsxToCatalog(buffer: Buffer): Promise<LocCatalog>;
 
 interface VoiceLine {
@@ -900,6 +1045,13 @@ declare function runInit(opts: InitOptions): InitResult;
  *  "switch VCS" path (which re-emits these for the newly-chosen VCS). No collision check - callers
  *  overwrite when switching. */
 declare function vcsConfigWrites(dir: string, vcs: InitVcs | undefined, bundle?: BundlePosture): PlannedWrite[];
+/**
+ * The bundle posture a project was set up with, read back from the files `init` wrote: the VCS's ignore
+ * file naming `*.patterc`, else `vcs-setup.md` saying the project ignores it (svn keeps its ignore list in
+ * a property). "commit" when neither says so. Switching VCS re-emits these files, and always writing
+ * "commit" lost the ignore rule of a project made with `init --bundle ignore`.
+ */
+declare function currentBundlePosture(dir: string, vcs: InitVcs | undefined): BundlePosture;
 
 /** The editor's caret context, so a search can float the current scene's hits (from the caret onwards) to
  *  the top. Omit for a context-free search (the CLI). */
@@ -985,6 +1137,8 @@ interface ReplaceOptions {
     wholeWord?: boolean;
     /** Restrict the replacement to a single beat id (the per-row "Replace this one"). */
     onlyId?: string;
+    /** The time stamped as each replaced string's `modifiedAt` (ISO 8601; default now). For tests. */
+    now?: string;
 }
 /** One replaced string, for the preview / confirm list. */
 interface ReplaceHit {
@@ -997,11 +1151,19 @@ interface ReplaceHit {
 }
 interface ReplacePlan {
     hits: ReplaceHit[];
-    /** Shard writes the caller commits through the VC layer (one per touched scene). */
+    /** Shard writes the caller commits through the VC layer: the string shards (one per touched scene) first,
+     *  then the authoring shards that carry their `modifiedAt` stamps (one per touched scene). */
     writes: PlannedWrite[];
-    /** The rewritten shard objects (index-aligned with `writes`), so the caller can swap them into its
-     *  in-memory `LoadedProject.locales` after committing: keeping reads + the open scene current. */
+    /** The rewritten string shard objects (index-aligned with the first `shards.length` of `writes`), so the
+     *  caller can swap them into its in-memory `LoadedProject.locales` after committing: keeping reads + the
+     *  open scene current. */
     shards: LocaleFile[];
+    /** The stamped authoring shards (the rest of `writes`, in order), for the caller to swap into its
+     *  in-memory `LoadedProject.authoring` after committing, so a later edit builds on the stamps. */
+    authoring: Array<{
+        path: string;
+        file: AuthoringFile;
+    }>;
     /** Distinct scenes touched. */
     scenes: number;
 }
@@ -1114,9 +1276,12 @@ declare function runMerge(base: Obj, ours: Obj, theirs: Obj, opts?: {
  *  (an empty result from `setIf` must not be reconsidered as "unhandled"). */
 declare const AUTHORING_HANDLED: Set<string>;
 
-/** A document entry whose path escapes the target dir (rejected). */
+/** A document entry whose path escapes the target dir, or that names a dot-file or dot-folder (rejected). */
 declare class UnsafeEntryError extends Error {
 }
+/** Bytes that are not a `.patterpack` at all: not a zip, or a zip holding no project file. */
+declare class NotAPackError extends Error {
+}
 /** What unpacking a document plans: its shards, and its game scopes snapshot (empty for a pack with none,
  *  which is every pack from before packs carried one). */
 interface UnpackResult {
@@ -1124,8 +1289,16 @@ interface UnpackResult {
     shards: PlannedWrite[];
     /** The game's scopes files, in `<targetDir>/game-scopes/`, where the new project finds them first. */
     scopes: PlannedWrite[];
+    /** Entries that are none of a shard, a scopes file or a handoff record, by name: never written. */
+    other: string[];
 }
-/** Unpack a `.patterpack` document (zip bytes) into planned writes under `targetDir`. */
+/**
+ * Unpack a `.patterpack` document (zip bytes) into planned writes under `targetDir`. Throws
+ * `NotAPackError` for bytes that are not a pack, `UnsafeEntryError` for an entry bound outside the target
+ * or naming a dot-file, and refuses a target that already holds a DIFFERENT project (its project id is
+ * not the pack's): that leaves two project files, and every later load fails. Unpacking over the same
+ * project, or into a folder with no project, is allowed.
+ */
 declare function runUnpack(bytes: Buffer | Uint8Array, targetDir: string): Promise<UnpackResult>;
 /** One shard's outcome in a merge-unpack. */
 interface MergedShard {
@@ -1134,6 +1307,8 @@ interface MergedShard {
     /** Merge result, or undefined when the shard was ADDED (new file from the author). */
     result?: MergeResult;
     added: boolean;
+    /** Whether there is a write for it: false when the merge leaves the shard saying what it already says. */
+    changed: boolean;
 }
 /**
  * Whether the three documents in a merge agree about WHICH PROJECT they are.
@@ -1164,10 +1339,13 @@ interface ProvenanceCheck {
 interface UnpackMergeResult {
     shards: MergedShard[];
     /** Merged (and added) shard contents to write into the project, and `game.scopes.json` when the
-     *  recipient changed the game's scopes (`gameScopes`). */
+     *  recipient changed the game's scopes (`gameScopes`). Only shards the merge changes. Commit `sidecars`
+     *  FIRST: a merged shard whose sidecar never landed is a conflict resolved to ours without a word. */
     writes: PlannedWrite[];
     /** `.patterconflict` sidecars for shards with conflicts. */
     sidecars: PlannedWrite[];
+    /** The returned pack's entries that are none of a shard, a scopes file or a handoff record: never written. */
+    other: string[];
     conflicts: number;
     warnings: number;
     /** Do the returned document, the base document and the target project agree on their project id? */
@@ -1445,4 +1623,4 @@ declare const REFUSE_MISSING_SHARE = 0.25;
 /** Plan an import. Reads the handoff record named in the document from the project. */
 declare function planEditableImport(loaded: LoadedProject, returned: ReturnedDoc, opts: ImportOptions): ImportPlan;
 
-export { AUTHORING_HANDLED, type ApplyStats, type BundlePosture, CONFLICT_SIDECAR, type CharacterReport, type Conflict, type ConflictKind, type ContentError, type CoverageAsyncHooks, type CoverageBeat, type CoverageHooks, type CoverageOptions, type CoverageOrder, type CoverageReport, type DecisionPlan, type DecisionResult, type DocumentManifest, type EditableScript, type EditableScriptOptions, type FormatResult, GAME_SCOPES_OWNER, type GameScopes, type GameScopesIssue, HANDOFF_DIR, type HandoffIssue, type HygieneIssue, type ImportOptions, type ImportPlan, type ImportProblem, type ImportReport, type InitOptions, type InitResult, type InitVcs, type LoadedProject, type LocCatalog, type LocEntry, type LocaleReport, type MergeFileType, type MergeResult, type MergedShard, type OpenSuggestion, PATTER_SCOPES_FILE, PATTER_SCOPES_OWNER, type PinPlan, type PinnedName, type PlannedWrite, type PlayEvent, type PlayOptions, type PlayOutcome, type PlayResult, type ProvenanceCheck, RARE_REACH_PCT, REFUSE_MISSING_SHARE, type Random, type ReadBox, type ReadComment, type ReadItem, type ReadMarker, type ReadParagraph, type ReadText, type ReplaceHit, type ReplaceOptions, type ReplacePlan, type ReportData, type ReportTotals, type ResolveEntry, type ReturnedDoc, SHARD_EXTENSIONS, type SceneReport, type ScriptDoc, type ScriptElement, type SearchFocus, type SuggestionDecision, type TrackedChange, type UnpackMergeResult, type UnpackResult, UnsafeEntryError, UnsupportedMergeError, type ValidateResult, type VoiceLine, type VoiceScript, type VoicedCounts, type WebExport, type WrittenCounts, applyLoc, applySceneOrder, applySuggestionDecisions, applyWrites, bundleOutputPath, catalogToJson, catalogToPo, catalogToXlsx, classesForChannel, defaultGameScopesDir, detectMergeType, discoverGameScopes, drivableScopes, exportEditableScript, extractLoc, findProjectFile, formatMarker, gameScopeTokens, gameScopesCatalogue, gameScopesSnapshot, handoffPath, handoffWrite, hostScopeTokens, issueMarkerCodes, jsonToCatalog, leastReachedFirst, listOpenSuggestions, listProjectTags, loadProject, loadProjectLanding, markerLength, newHandoffId, parseHandoff, patterScopesFile, patterScopesStale, patterScopesWrite, planEditableImport, planPins, planReturnedWorld, planShareScopes, planWorldSave, poToCatalog, previewRegistry, proposeCoverageDrivers, reachabilityIssues, readEditableDocx, readGameScopes, readHandoff, readHandoffs, readMarker, renderCoverageText, renderPlay, renderReportText, resolveDocumentation, resolveStart, runCoverage, runCoverageAsync, runExport, runExportFull, runExportHtml, runExportWeb, runFormat, runInit, runMerge, runPack, runPlay, runPropertyUsage, runReplace, runReport, runReportXlsx, runResolve, runScriptDoc, runSearch, runStatusBrowse, runTagBrowse, runUnpack, runUnpackMerge, runValidate, runVoiceScript, scanAudioStatus, sceneIdForShard, scriptToDocx, scriptToPdf, serialiseHandoff, setCut, sidecarIssues, staleParts, vcsConfigWrites, voiceScriptToXlsx, worldSettingsScopes, xlsxToCatalog };
+export { AUDIO_MANIFEST_FILE, AUDIO_MANIFEST_SCHEMA, AUTHORING_HANDLED, type ApplyStats, type AudioEntry, type AudioRung, type AudioSnapshot, type BuildPlan, type BundlePosture, CONFLICT_SIDECAR, type CharacterReport, type Conflict, type ConflictKind, type ContentError, type CoverageAsyncHooks, type CoverageBeat, type CoverageHooks, type CoverageOptions, type CoverageOrder, type CoverageReport, type DecisionPlan, type DecisionResult, type DocumentManifest, type EditableScript, type EditableScriptOptions, type ExportOptions, type FormatResult, GAME_SCOPES_OWNER, type GameScopes, type GameScopesIssue, HANDOFF_DIR, type HandoffIssue, type HygieneIssue, type ImportOptions, type ImportPlan, type ImportProblem, type ImportReport, type InitOptions, type InitResult, type InitVcs, type LoadedProject, type LocCatalog, type LocEntry, type LocaleReport, type MergeFileType, type MergeResult, type MergedShard, NotAPackError, type OpenSuggestion, PATTER_SCOPES_FILE, PATTER_SCOPES_OWNER, type PinPlan, type PinnedName, type PlannedWrite, type PlayEvent, type PlayOptions, type PlayOutcome, type PlayResult, type ProvenanceCheck, RARE_REACH_PCT, REFUSE_MISSING_SHARE, type Random, type ReadBox, type ReadComment, type ReadItem, type ReadMarker, type ReadParagraph, type ReadText, type ReplaceHit, type ReplaceOptions, type ReplacePlan, type ReportData, type ReportTotals, type ResolveEntry, type ReturnedDoc, SHARD_EXTENSIONS, type SceneReport, type ScriptDoc, type ScriptElement, type SearchFocus, type SuggestionDecision, type TrackedChange, type UnpackMergeResult, type UnpackResult, UnsafeEntryError, UnsupportedMergeError, type ValidateResult, type VoiceLine, type VoiceScript, type VoicedCounts, type WebExport, type WrittenCounts, applyLoc, applySceneOrder, applySuggestionDecisions, applyWrites, audioFolderRungs, audioFoldersActive, audioManifest, audioManifestWrite, besideBundlePath, bundleOutputPath, catalogToJson, catalogToPo, catalogToXlsx, classesForChannel, compileLoaded, currentBundlePosture, defaultBundlePath, defaultGameScopesDir, detectMergeType, discoverGameScopes, drivableScopes, exportBlockers, exportEditableScript, extractLoc, findProjectFile, formatMarker, gameScopeTokens, gameScopesCatalogue, gameScopesSnapshot, handoffPath, handoffWrite, hostScopeTokens, issueMarkerCodes, jsonToCatalog, leastReachedFirst, listOpenSuggestions, listProjectTags, loadProject, loadProjectLanding, markerLength, newHandoffId, parseHandoff, patterScopesFile, patterScopesStale, patterScopesWrite, pickAudio, planBuild, planEditableImport, planPins, planReturnedWorld, planShareScopes, planWorldSave, poToCatalog, previewRegistry, proposeCoverageDrivers, reachabilityIssues, readEditableDocx, readGameScopes, readHandoff, readHandoffs, readMarker, renderCoverageText, renderPlay, renderReportText, resolveDocumentation, resolveStart, runCoverage, runCoverageAsync, runExport, runExportFull, runExportHtml, runExportWeb, runFormat, runInit, runMerge, runPack, runPlay, runPropertyUsage, runReplace, runReport, runReportXlsx, runResolve, runScriptDoc, runSearch, runStatusBrowse, runTagBrowse, runUnpack, runUnpackMerge, runValidate, runVoiceScript, scanAudio, scanAudioStatus, sceneIdForShard, scriptToDocx, scriptToPdf, serialiseHandoff, setCut, sidecarIssues, staleParts, vcsConfigWrites, voiceScriptToXlsx, worldSettingsScopes, xlsxToCatalog };