@hypit/hypit 0.1.5 → 0.1.6

package/examples/semantic-composition/README.md

@@ -28,7 +28,8 @@ node bin/hypit.mjs check examples/semantic-composition/chat.svml --workspace exa
 node bin/hypit.mjs build examples/semantic-composition/chat.svrun --workspace examples/semantic-composition --runtime examples/semantic-composition/hypit.runtime.json --follow
 ```
 
-The Profile selects local HyperFrames and FFmpeg. Use the machine's prepared browser/media tools;
+The Profile selects local HyperFrames and FFmpeg. Its execution data lives in `.hypit/runtimes/local`;
+`.hypit/runtime` is reserved for the project's Profile-selection file. Use the machine's prepared browser/media tools;
 there is no hosted generation account in this example. The final Output is `final.video`. The same
 Run can be opened in Studio, where its component lane and physical clock work without a Script lane.
 For an independent project, install `@hypit/hypit`, copy the component into `packages/`, replace its workspace

package/examples/semantic-composition/chat.svml

@@ -9,7 +9,7 @@
   <import as="style" source="./chat.svs"/>
 
   <time:Clock id="animation-clock" frame-rate="30"/>
-<time:Timeline id="animation" clock={animation-clock} end="8s"/>
+  <time:Timeline id="animation" clock={animation-clock} end="8s"/>
   <spatial:Canvas id="canvas" width="540" height="960"/>
   <fonts:Stack id="font" family="inter" weight="600" style="normal"/>
   <chat:Scene id="conversation" timeline={animation.timeline} canvas={canvas} font={font}

package/examples/semantic-composition/hypit.runtime.json

@@ -1,6 +1,6 @@
 {
   "format": "hypit.runtime-local@1",
-  "dataRoot": ".hypit/runtime",
+  "dataRoot": ".hypit/runtimes/local",
   "endpoints": {
     "media.local": { "use": "@hypit/provider-media-local", "config": { "defaultConcurrency": 2 } },
     "hyperframes.local": { "use": "@hypit/provider-hyperframes-local", "config": { "workers": 2, "defaultConcurrency": 1 } }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hypit/hypit",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "homepage": "https://hypit.ai",
   "repository": {
     "type": "git",
@@ -125,6 +125,8 @@
     "packages/*/README.md",
     "packages/temporal-markup/EDITING.md",
     "packages/studio/INSPECTOR.md",
+    "packages/studio/LOCALIZATION.md",
+    "packages/studio/locales/*.json",
     "services/image-opencv/pyproject.toml",
     "services/image-opencv/package.json",
     "services/image-opencv/uv.lock",
@@ -172,6 +174,7 @@
     "docs:build": "vitepress build docs",
     "docs:preview": "vitepress preview docs",
     "test": "node test/run.mjs",
+    "test:runtime-scale": "node test/run.mjs runtime-scale",
     "test:whisperx-service": "uv run --project services/whisperx --frozen python -m unittest discover -s services/whisperx/tests -p \"test_*.py\"",
     "test:image-opencv": "node test/run.mjs image-opencv",
     "hypit": "node bin/hypit.mjs",

package/packages/caption-fine/README.md

@@ -87,6 +87,13 @@ individual Han characters as Display Words; punctuation stays with its display w
 those units for timing and active Paint, while authored Cues remain complete reading phrases.
 Dual Text retains its complete alignment unit even when it displays or speaks several words.
 
+`<组件化|>` authors the same unit as `<组件化|组件化>` without repeating the speech. Fine's `step`
+karaoke, active underline and active box treat that unit together using its first-to-last speech
+interval. Ordinary Chinese characters around it retain their own activation times. This is an
+explicit authored group, not a renderer-selected segmentation, and does not introduce a new Cue.
+The underlying character anchors remain available to other Timeline consumers. `wipe` and
+`typewriter` still animate inside the complete unit over its interval when deliberately selected.
+
 `word-gap` applies between Latin words and at Chinese/Latin boundaries. Adjacent Han characters and
 full-width punctuation carry no extra word gap. `letter-spacing` controls glyph tracking. Exact
 font fallbacks supply the required glyphs; the layout does not select a font by language.

package/packages/cli/src/view.ts

@@ -164,6 +164,8 @@ export function buildStatusView(options: {
     ? "unavailable" as const
     : options.result?.outcome ?? (options.result === undefined ? "missing" as const : "open" as const);
   const issue = options.runtime?.issue;
+  const operations = (options.runtime?.operations ?? options.result?.operations ?? [])
+    .filter((item) => options.verbose || item.status !== "completed");
   return {
     id: options.id,
     ...((options.runtime?.targets ?? options.result?.targets) === undefined ? {} : {
@@ -197,9 +199,8 @@ export function buildStatusView(options: {
           }
         : { message: options.resultReadError! },
     }),
-    ...((options.runtime?.operations ?? options.result?.operations ?? []).some((item) => item.status !== "completed") ? {
-      operations: groupOperationViews((options.runtime?.operations ?? options.result?.operations ?? [])
-        .filter((item) => item.status !== "completed")
+    ...(operations.length > 0 ? {
+      operations: groupOperationViews(operations
         .map((item) => ({
           ...(!options.verbose ? {} : "operation" in item ? { id: item.operation } : item.id === undefined ? {} : { id: item.id }),
           ...(item.receipt === undefined || (!options.verbose && item.failure === undefined) ? {} : { receipt: item.receipt }),

package/packages/film/src/surface.ts

@@ -117,7 +117,10 @@ export const decodeFilmSurface: StructuredSurfaceHandler = ({ element, resolveRe
     const name = `track-${index + 1}`;
     return { name, kind: trackKind(source), source };
   });
-  if (new Set(tracks.map((track) => track.name)).size !== tracks.length) {
+  const sourceKeys = tracks.map(({ source: { ref } }) => ref.kind === "record"
+    ? `record\u0000${ref.id}`
+    : `component-output\u0000${ref.component}\u0000${ref.output}`);
+  if (new Set(sourceKeys).size !== tracks.length) {
     throw new Error(`${element.name} cannot include the same Track more than once`);
   }
   const fragment = createFilmAssemblyFragment({ name: "@hypit/film/surface-assembly@1", tracks });

package/packages/runtime-local/README.md

@@ -122,6 +122,12 @@ for a submission that never became active and therefore has no Result to save.
 Source imports select author packages. Runtime Profile entries select only code allowed to access files,
 credentials, processes or networks. Installing a package changes neither selection.
 
+Endpoint scoping happens before activation when explicit instance IDs are supplied, or when every
+requested capability has a binding. Otherwise discovery loads the Profile's Endpoint packages to
+find eligible implementations. Thus unused service readiness is not required, but an uninstalled
+declared package can still prevent unbound discovery. `scopedProfile` owns this distinction; package
+names are not used to guess which capabilities they supply.
+
 The lifecycle commands have deliberately narrow meanings:
 
 - `hypit runtime init` writes and selects the Distribution's starter Profile; it performs no setup or
@@ -224,3 +230,14 @@ Managed Programs have independent lifetimes. A healthy WhisperX service keeps it
 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
 environment; external writable Credential Stores resolve through their own implementation.
+
+### Concurrency checks
+
+`pnpm test` exercises 24 Builds with an eight-task remote pool and with all 24 submissions pending
+at once. Both cases verify local progress, per-Build module isolation, one submission per Build,
+capacity release and every completed Result. They use the production execution process and SQLite.
+
+`pnpm test:runtime-scale` runs the same checks with 1000 simultaneous remote submissions, on its own.
+This is a load experiment rather than part of every package regression. It reports fixture preparation,
+local progress, completion, executor RSS and cleanup separately; total test time also includes creating
+and removing the temporary Result repositories. Neither suite uses a completion-time performance target.

package/packages/script/README.md

@@ -64,7 +64,7 @@ CaptionDocument contracts.
 - **Role Cue**: a speaker turn, written as a bare tag such as `<ALICE>` inside a Segment. The next
   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>`.
+  `<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!`.
 - **CaptionDocument**: the Script-owned caption truth; it contains **Display Words**,
@@ -73,11 +73,23 @@ CaptionDocument contracts.
   `really{emphasis,importance=2,tone=warm}`. Values may be strings, finite numbers or booleans. It
   becomes `CaptionDisplayWord.attributes`; it is not a Selection and does not carry timing.
 
-Within Dual Text, an unescaped `@` is legal only on the spoken side. The display side is literal; write
-`\@` if an at-sign must be shown. An empty display side, such as `< | spoken words>`, keeps the speech
+Within Dual Text, an unescaped `@` belongs to the source of spoken text: the right side when supplied,
+or the shared left side in `<display text|>`. Write `\@` if an at-sign must be shown. An empty display side, such as `< | spoken words>`, keeps the speech
 tokens and omits them from Caption. `||` is an authored Caption Cue Break and must occur between
 complete Alignment Units.
 
+`<组件化|>` is shorthand for `<组件化|组件化>`, using the same exported Caption Alignment Unit.
+It groups the displayed expression without merging its individual speech Tokens or time anchors.
+For example, `把<动效|><组件化|>。|| 之后<直接复用|>。` authors groups inside two Cues.
+Use groups where the expression should be treated together; ordinary prose needs no extra markup.
+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
+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.
+
 ## Segments, turns and Cues are different boundaries
 
 A Segment names a structural production passage. It can contain several Role turns and be performed

package/packages/script/src/manifest.ts

@@ -64,7 +64,8 @@ export const scriptMarkupSurfaces = [
         "A Script requires at least one Segment, and natural-language text is refused outside a Segment.",
         "A Segment is opened by its own lower-case name and closed by that exact name, or written self-closing as `<pause/>`; the name is the Segment id, must be unique within the Script, and `script` is reserved. Segments do not nest.",
         "A Role Cue such as `<HOST>` is a bare tag inside a Segment with no close; its turn runs until the next Cue or the end of the Segment, and a Cue may not follow unowned speech in the same Segment. Role state resets when the Segment closes.",
-        "Dual Text is written `<display | speech>`: the left side reaches the caption projection and the right side reaches dialogue and speech. The spoken side must not be empty; the displayed side may be, which speaks a word that is never displayed.",
+        "Dual Text is written `<display | speech>`: the left side reaches Caption and the right side reaches dialogue and speech. `<display|>` inherits speech from the displayed prose and forms the same complete alignment unit; its word times remain individual. `<|speech>` speaks without displaying. Both sides empty is invalid.",
+        "Inside Dual Text, semantic markers belong to the source of spoken text: the explicit right side, or the shared left side when speech is omitted. Display attributes remain visual metadata and never enter spoken text.",
         "A flat token attribute follows a complete display token as `{name}` or `{name=value}`; multiple attributes use one comma-separated block. Attributes do not nest, do not carry timing, and never split a Dual Alignment Unit.",
         "Selection and Moment markers are zero-width, share one name namespace, and may not split a speech token:",
         [

package/packages/script/src/parser.ts

@@ -499,16 +499,22 @@ export function parseScript(
   const consumeSpeechSide = (
     raw: string,
     absoluteStart: number,
-    caption: string,
+    caption: string | undefined,
     marks: ParsedCaptionRegion["marks"] = [],
   ): void => {
     const startToken = tokens.length;
+    // An omitted speech side shares the written display source. Keep its original offsets:
+    // marker edits target these words, not a synthetic copy beyond the pipe.
+    const shared = caption === undefined;
+    const spokenParts: string[] = [];
+    const sharedMarks: Array<ParsedCaptionRegion["marks"][number]> = [];
     let partStart = 0;
     let index = 0;
     let emittedCaption = false;
     const addLiteral = (part: string, start: number): void => {
       for (const piece of literalPieces(part, start, true)) {
-        addText(piece.value, emittedCaption ? "" : caption, piece.start, piece.end, false, piece.positions);
+        spokenParts.push(piece.value);
+        addText(piece.value, shared ? piece.value : emittedCaption ? "" : caption!, piece.start, piece.end, false, piece.positions);
         emittedCaption = true;
       }
     };
@@ -520,6 +526,29 @@ export function parseScript(
       if (raw.startsWith("||", index)) {
         fail("SCRIPT_CAPTION_BREAK_DUAL", "Caption Cue break cannot occur inside Dual Text; split the Dual Text into separate units.", absoluteStart + index);
       }
+      if (shared && raw[index] === "{") {
+        const before = raw.slice(partStart, index);
+        if (!before || /\s$/u.test(before)) {
+          fail("SCRIPT_ATTRIBUTE_TARGET", "A token attribute must immediately follow a display token.", absoluteStart + index);
+        }
+        addLiteral(before, absoluteStart + partStart);
+        const block = parseAttributeBlock(raw.slice(index), absoluteStart + index);
+        const displayIndex = displayWordSurfaces(spokenParts.join("")).length - 1;
+        if (displayIndex < 0 || tokens.length === startToken) {
+          fail("SCRIPT_ATTRIBUTE_TARGET", "A token attribute must follow a visible display token.", absoluteStart + index);
+        }
+        if (sharedMarks.some(mark => mark.displayIndex === displayIndex)) {
+          fail("SCRIPT_ATTRIBUTE_OVERLAP", "A display token cannot receive two separate attribute blocks.", absoluteStart + index);
+        }
+        sharedMarks.push({ displayIndex, attributes: block.attributes });
+        const token = tokens.at(-1)!;
+        tokens[tokens.length - 1] = { ...token, editRange: {
+          start: token.editRange.start, end: sourceOffset + absoluteStart + index + block.length,
+        } };
+        index += block.length;
+        partStart = index;
+        continue;
+      }
       const marker = parseMarker(raw, index);
       if (!marker) {
         if (raw[index] === "@") fail("SCRIPT_MARKER", "Unescaped @ must begin a valid marker.", absoluteStart + index);
@@ -532,15 +561,19 @@ export function parseScript(
       partStart = index;
     }
     addLiteral(raw.slice(partStart), absoluteStart + partStart);
+    const display = caption ?? spokenParts.join("");
+    if (shared && tokens.length === startToken) {
+      fail("SCRIPT_DUAL_EMPTY", "Dual Text with omitted speech must contain spoken text on its display side.", absoluteStart);
+    }
     if (tokens.length > startToken) {
       addCaptionRegion(
-        caption,
+        display,
         current!.id,
         startToken,
         tokens.length,
-        cleanProjection(caption) ? "alias" : "hidden",
+        cleanProjection(display) ? "alias" : "hidden",
         { start: sourceOffset + absoluteStart, end: sourceOffset + absoluteStart + raw.length },
-        marks,
+        shared ? sharedMarks : marks,
       );
     }
   };
@@ -636,10 +669,16 @@ export function parseScript(
       const pipe = findUnescaped(inside, "|");
       if (pipe >= 0) {
         finishLexicalRun();
+        const speech = inside.slice(pipe + 1);
+        if (!speech.trim()) {
+          consumeSpeechSide(inside.slice(0, pipe), offset + 1, undefined);
+          finishLexicalRun();
+          offset = end + 1;
+          continue;
+        }
         assertDualDisplayLiteral(inside.slice(0, pipe), offset + 1);
         const markedDisplay = parseMarkedDisplay(inside.slice(0, pipe), offset + 1);
         const display = markedDisplay.display;
-        const speech = inside.slice(pipe + 1);
         if (!speech.replace(/~?@\/?[A-Za-z_][A-Za-z0-9_.-]*!?~?/gu, "").trim()) {
           fail("SCRIPT_DUAL_EMPTY", "Dual Text speech side must not be empty.", offset);
         }

package/packages/studio/LOCALIZATION.md

@@ -0,0 +1,98 @@
+# Localizing Studio
+
+Studio owns its interface messages; a language pack supplies their wording. The
+English catalog in [locales/en.json](locales/en.json) is the complete list of
+message IDs. [Simplified Chinese](locales/zh-CN.json) uses exactly the same format
+as any additional language. A pack is JSON data, not executable code.
+
+## Add a language
+
+Copy `locales/en.json`, change `locale` (a BCP 47 tag such as `ja` or `pt-BR`),
+`name` (the language's native name), and translate the message values. Keep the
+message IDs. `direction` is `ltr` or `rtl` and controls translated text; it does
+not reverse the physical video timeline or canvas coordinates.
+
+A small, valid starting point is:
+
+```json
+{
+  "locale": "ja",
+  "name": "日本語",
+  "direction": "ltr",
+  "messages": {
+    "app.studio": "スタジオ",
+    "app.comments": "コメント",
+    "app.language": "言語"
+  }
+}
+```
+
+Missing messages use English, so a partial translation is useful immediately.
+Text is displayed as text, never interpreted as HTML. Preserve named variables
+such as `{name}` and `{count}`; their order may change to suit the language.
+Messages with `{count}` can be strings or plural forms:
+
+```json
+{ "one": "{count} item", "other": "{count} items" }
+```
+
+Use the language's `Intl.PluralRules` categories (`zero`, `one`, `two`, `few`,
+`many`, `other`); `other` is required. Numbers and interface dates use the chosen
+locale. Choose natural full sentences instead of assembling translated fragments.
+
+Check and load your file:
+
+```sh
+hypit studio --check-locale ./ja.json
+hypit studio --run ./render.svrun --locale-pack ./ja.json
+```
+
+The check lists missing translations and unknown IDs and reports malformed
+messages or renamed variables. It does not open a Run or require a Runtime.
+Relative file paths start at the command's working directory; prefix them with
+`./` or `../`. Repeat `--locale-pack` to load multiple languages. Packs are read
+at server startup; restart Studio after editing a pack. An explicitly loaded
+pack with an existing locale replaces that locale's pack, with English fallback
+for any omitted messages.
+
+## Share a language pack
+
+A local file is sufficient. For reuse, publish it through an ordinary package
+under your own scope; there is no Hypit language registry or separate approval
+step. Export the JSON file in the package's `package.json`, for example:
+
+```json
+{
+  "name": "@your-scope/studio-ja",
+  "version": "1.0.0",
+  "files": ["ja.json"],
+  "exports": { "./locale.json": "./ja.json" }
+}
+```
+
+Install it using the project's package manager, then load it explicitly:
+
+```sh
+hypit studio --run ./render.svrun --locale-pack @your-scope/studio-ja/locale.json
+```
+
+Package exports resolve from the project, or `--package-root` when specified.
+Studio reads the resolved JSON without importing package code. It neither scans
+for language packs nor installs missing packages.
+
+## Interface behavior and ownership
+
+The globe menu to the left of **Studio / Comments** lists loaded languages by
+their native names. The first visit follows the browser's language preferences;
+subsequent visits retain the choice saved in that browser. Switching updates
+marked labels in place, preserving the playhead, selection and comment draft.
+
+Only Studio-owned interface text belongs in this catalog. Component names,
+Companion-supplied labels, Source code, user comments and raw service diagnostics
+retain their original text. Language packs do not change the Companion ABI,
+Core, compilation, or rendering. A component remains the owner of its labels.
+
+When adding Studio UI, give each message a stable ID in the English catalog and
+use the helpers in `src/ui/i18n.ts` for text and attributes. Do not use English
+wording as IDs, inspect DOM text to guess what needs translation, or put language
+branches into components. Keep interpolation values separate from message text.

package/packages/studio/README.md

@@ -258,3 +258,16 @@ audibility regions and target-relative fades. Web Audio gain nodes schedule the
 on the same clock, including silence and amplification above unity. Visual video elements stay muted;
 the Film's selected AudioTracks own composition sound. Seeking is silent. This path is independent of
 which component emitted a clip.
+
+### Interface language
+
+The globe menu to the left of **Studio / Comments** selects a language. English
+and Simplified Chinese are included; additional JSON language packs can be loaded
+with `--locale-pack`, from local files or installed package exports. The first
+visit follows browser preferences, and later visits remember the user's choice.
+Switching preserves the playhead, selection and comment draft.
+
+[Localizing Studio](LOCALIZATION.md) explains the message catalog, plural forms,
+translation checks and language-pack distribution. Only Studio-owned interface
+text is translated; Companion labels, project content and raw diagnostics retain
+their original text. The Companion ABI is unchanged.

package/packages/studio/locales/en.json

@@ -0,0 +1,197 @@
+{
+  "locale": "en",
+  "name": "English",
+  "direction": "ltr",
+  "messages": {
+    "app.comments": "Comments",
+    "app.language": "Language",
+    "app.studio": "Studio",
+    "app.studio-view": "Studio view",
+    "comments.all": "All",
+    "comments.caught-up": "All caught up",
+    "comments.delete-comment": "Delete comment",
+    "comments.done": "Done",
+    "comments.draw-soon": "Draw — coming later",
+    "comments.edit-comment": "Edit comment",
+    "comments.edit-comment-text": "Edit comment text",
+    "comments.emoji-soon": "Emoji — coming later",
+    "comments.empty": "A note starts here",
+    "comments.empty-hint": "Pause on a frame and describe what you would like to change.",
+    "comments.filter-comments": "Filter comments",
+    "comments.filter-hint": "Switch filters to see the other comments.",
+    "comments.go-to-this-frame": "Go to this frame",
+    "comments.loading-comments": "Loading comments…",
+    "comments.mark-complete": "Mark complete",
+    "comments.no-completed-comments": "No completed comments",
+    "comments.open": "Open",
+    "comments.placeholder": "What would you like to change?",
+    "comments.read-failed": "Could not read comments.",
+    "comments.refresh-comments": "Refresh comments",
+    "comments.reopen-comment": "Reopen comment",
+    "comments.save-failed": "Could not save comment.",
+    "comments.send-comment": "Send comment",
+    "comments.send-shortcut": "Send comment (Enter)",
+    "comments.use-current-frame": "Use current frame",
+    "comments.write-a-comment": "Write a comment",
+    "common.cancel": "Cancel",
+    "common.cancelled": "Cancelled",
+    "common.compile-failed": "Compile failed",
+    "common.completed": "Completed",
+    "common.copied": "Copied",
+    "common.failed": "Failed",
+    "common.invalid-value": "Invalid value",
+    "common.needs-attention": "Needs attention",
+    "common.queued": "Queued",
+    "common.refresh": "Refresh",
+    "common.running": "Running",
+    "common.save": "Save",
+    "common.save-failed": "Save failed",
+    "common.saved": "Saved",
+    "common.saving": "Saving",
+    "common.waiting": "Waiting",
+    "inspector.add-color": "Add color",
+    "inspector.add-item": "Add item",
+    "inspector.anchor.program-end": "Timeline end{detail}",
+    "inspector.anchor.program-start": "Timeline start{detail}",
+    "inspector.anchor.segment-end": "Segment end{detail}",
+    "inspector.anchor.segment-start": "Segment start{detail}",
+    "inspector.anchor.token-end": "Word end{detail}",
+    "inspector.anchor.token-start": "Word start{detail}",
+    "inspector.aspect-ratio": "Aspect ratio",
+    "inspector.author": "Author",
+    "inspector.build": "Build",
+    "inspector.candidates": "Candidates",
+    "inspector.canvas": "Canvas",
+    "inspector.duration": "Duration",
+    "inspector.empty": "No details for this selection",
+    "inspector.end": "End",
+    "inspector.end-anchor": "End semantic anchor",
+    "inspector.frame-rate": "Frame rate",
+    "inspector.frames": "Frames",
+    "inspector.how": "How",
+    "inspector.invalid-fields": "Complete the required fields with valid values to save.",
+    "inspector.item-count": {
+      "one": "{count} item",
+      "other": "{count} items"
+    },
+    "inspector.moment": "Moment",
+    "inspector.moment-anchor": "Moment semantic anchor",
+    "inspector.move-down": "Move down",
+    "inspector.move-up": "Move up",
+    "inspector.project": "Project",
+    "inspector.properties": "Properties",
+    "inspector.remove-item": "Remove item",
+    "inspector.resolution": "Resolution",
+    "inspector.run": "Run",
+    "inspector.semantic-anchors": "Semantic anchors",
+    "inspector.sources": "Sources",
+    "inspector.start": "Start",
+    "inspector.start-anchor": "Start semantic anchor",
+    "inspector.structured-value": "Structured value",
+    "inspector.targets": "Targets",
+    "inspector.timeline": "Timeline",
+    "inspector.timing": "Timing",
+    "inspector.tracks": "Tracks",
+    "inspector.use-color": "Use {color}",
+    "inspector.when": "When",
+    "inspector.where": "Where",
+    "library.all-media": "All media",
+    "library.all-tasks": "All tasks",
+    "library.artifacts": "Artifacts",
+    "library.audio": "Audio",
+    "library.clear-task-filter": "Clear task filter",
+    "library.data": "Data",
+    "library.display-name": "Display name",
+    "library.enter-name": "Enter a name.",
+    "library.finished": "Finished",
+    "library.image": "Image",
+    "library.images": "Images",
+    "library.in-progress": "In progress",
+    "library.loading-media": "Loading media…",
+    "library.loading-more": "Loading more…",
+    "library.loading-tasks": "Loading tasks…",
+    "library.media-categories": "Media categories",
+    "library.media-category": "Media category",
+    "library.media-hint": "Images, videos and audio published as file Outputs appear here, including those from ongoing Builds.",
+    "library.name-failed": "Could not save the name",
+    "library.name-pending": "{name}\nNaming is available when this Build finishes",
+    "library.no-files-in-this-category": "No files in this category",
+    "library.no-media": "No media",
+    "library.no-tasks-here": "No tasks here",
+    "library.no-tasks-in-progress": "No tasks in progress",
+    "library.preview-name": "Preview {name}",
+    "library.preview-unavailable": "Preview unavailable",
+    "library.referenced-source-files": "Referenced source files",
+    "library.refresh-failed": "Refresh failed: {detail}",
+    "library.refresh-failed-retained": "Refresh failed: {detail} · Previous view retained",
+    "library.refresh-interrupted": "Refresh interrupted",
+    "library.refresh-media": "Refresh media",
+    "library.refresh-tasks": "Refresh tasks",
+    "library.refreshing": "Refreshing…",
+    "library.rename-hint": "{name}\nDouble-click or press F2 to rename",
+    "library.return-to-task": "Return to task",
+    "library.source": "Source",
+    "library.studio-library": "Studio library",
+    "library.task-categories": "Task categories",
+    "library.task-return": "{name} · Return to task",
+    "library.tasks": "Tasks",
+    "library.unavailable": "Library unavailable",
+    "library.updated": "Updated {time}",
+    "library.video": "Video",
+    "library.video-loading-preview": "Video · Loading preview",
+    "library.videos": "Videos",
+    "library.view-media": "View media",
+    "library.view-task-media": "View task media",
+    "player.audio-waveform": "Audio waveform",
+    "player.back-5-seconds": "Back 5 seconds",
+    "player.back-to-composition": "Back to composition",
+    "player.composition-time": "Composition time",
+    "player.elements-at-this-point": "Elements at this point",
+    "player.forward-5-seconds": "Forward 5 seconds",
+    "player.frame-loading": "Loading frame…",
+    "player.frame-unavailable": "Frame unavailable",
+    "player.hovered-frame": "Hovered frame",
+    "player.media-failed": "This media could not be opened in the browser.",
+    "player.media-time": "Media time",
+    "player.mute": "Mute",
+    "player.next-frame": "Next frame",
+    "player.pause": "Pause",
+    "player.play": "Play",
+    "player.preview": "Preview",
+    "player.previous-frame": "Previous frame",
+    "player.unmute": "Unmute",
+    "source.changed-outside-studio": "Changed outside Studio",
+    "source.edit-source": "Edit source",
+    "source.keep-lines-unwrapped": "Keep lines unwrapped",
+    "source.read-source": "Read source",
+    "source.save-failed-status": "Save failed ({status})",
+    "source.saving-before-switch": "Saving before switch",
+    "source.svml-source": "SVML source",
+    "source.unsaved": "Unsaved",
+    "source.wrap-lines": "Wrap lines",
+    "tasks.copy-error": "Copy error",
+    "tasks.copy-manually": "Select the text to copy",
+    "tasks.no-runtime": "No Runtime is selected. Saved tasks are available under Finished.",
+    "tasks.progress": "{completed}/{total} steps complete",
+    "tasks.refresh-hint": "Refresh to read the latest task status.",
+    "tasks.saved-only": "Saved project Results · no Runtime selected",
+    "timeline.fit-timeline": "Fit timeline",
+    "timeline.moment-name": "Moment {name}",
+    "timeline.overlapping-timeline-objects": "Overlapping timeline objects",
+    "timeline.resize-timeline-track-labels": "Resize timeline track labels",
+    "timeline.resize-track-labels": "Resize track labels",
+    "timeline.segment-name": "Segment {name}",
+    "timeline.segments": "Segments",
+    "timeline.select": "Select",
+    "timeline.selection-name": "Selection {name}",
+    "timeline.selections-and-moments": "Selections and Moments",
+    "timeline.words": "Words",
+    "timeline.zoom-in": "Zoom in",
+    "timeline.zoom-out": "Zoom out",
+    "inspector.color-picker": "{label} picker",
+    "timeline.segment-count": {
+      "one": "{count} segment",
+      "other": "{count} segments"
+    }
+  }
+}