@hypit/hypit 0.1.5 → 0.1.7

package/README.md

@@ -16,7 +16,7 @@
 </p>
 
 <p align="center">
-  <a href="https://github.com/hypit-ai/hypit/stargazers"><img alt="Stars" src="https://img.shields.io/github/stars/hypit-ai/hypit?style=flat-square&color=FFD700&logo=github&logoColor=white&label=Stars"></a>
+  <img alt="Stars" src="https://img.shields.io/github/stars/hypit-ai/hypit?style=flat-square&color=FFD700&logo=github&logoColor=white&label=Stars">
   <a href="https://github.com/hypit-ai/hypit/blob/main/package.json"><img alt="Node 22.15+" src="https://img.shields.io/badge/Node.js-22.15%2B-5FA04E?style=flat-square&logo=nodedotjs&logoColor=white"></a>
   <a href="https://github.com/hypit-ai/hypit/blob/main/package.json"><img alt="pnpm 10.33" src="https://img.shields.io/badge/pnpm-10.33-F69220?style=flat-square&logo=pnpm&logoColor=white"></a>
   <a href="https://github.com/hypit-ai/hypit/blob/main/package.json"><img alt="TypeScript 5.9" src="https://img.shields.io/badge/TypeScript-5.9-3178C6?style=flat-square&logo=typescript&logoColor=white"></a>

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.7",
   "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/provider-hypihub/README.md

@@ -74,9 +74,13 @@ to the selected deployment's origin or an existing `/v1`/`/v1beta` base. The Run
 normalizes it to `/v1`; missing or insufficient user
 credentials should be resolved at [hypit.ai](https://hypit.ai). Referenced image, audio and video
 Resources are uploaded through a session from `POST /v1/files/uploads`, followed by the private
-regional multipart instructions returned by HypiHub. The Provider follows the server-selected part
+regional multipart instructions or `api_multipart` file POST selected by HypiHub. The latter sends
+one multipart/form-data file to the selected service's `/v1/files`, preserving reference purpose
+and person classification; an uncertain file POST is not repeated automatically.
+For direct multipart uploads, the Provider follows the server-selected part
 size and part concurrency, retries a failed part with a fresh signed URL, completes or cancels that
-one upload, and then passes the returned HTTPS URL to generation or transcription. One
+one upload, and then passes the returned HTTPS URL to generation or transcription. Signing requests
+contain at most the service's 128-part limit; all batches belong to the same upload. One
 Resource identity with the same declared person-reference classification is uploaded once within one Runtime operation. Hypit keeps no upload catalog or
 cross-Build cache. Seedance visual references can carry `personReference` in their media fields;
 the mapping declares it as a resource-transport field and the upload session receives
@@ -97,13 +101,23 @@ selected Store is writable. Its Endpoint receives only the credential slot it de
 operation for replacing that same slot; it cannot enumerate the Store, choose another key or read
 another Endpoint's credentials. A raw credential remains an ordinary static API key.
 
+Refresh uses `oauthRequestTimeoutMs` during generation, transcription, uploads and pricing too.
+It completes before the subsequent API request starts its own deadline. A stalled refresh reports
+an OAuth refresh timeout without starting that API request.
+
 The service currently requires whole-file and per-part SHA-256 values as fields of its signed upload
 protocol. They exist only while transferring bytes; Hypit never uses them as Resource identity,
 Result metadata, lookup keys or reuse evidence. Signed URLs and their query credentials are removed
 from surfaced upload errors.
 
 The default remote alignment model is `victor-upmeet/whisperx`; `transcriptionModel` may select another
-HypiHub model that exposes the `transcriptions` route. `hypit doctor` reads the authenticated model
+HypiHub model that exposes the `transcriptions` route. When transcription response headers include
+`X-Request-Id`, the Provider records it in the existing execution diagnostics before reading the body.
+A matching same-service `Location` is retained as the authenticated result lookup URL, including on
+an HTTP failure or interrupted response body. This is a receipt for investigation, not automatic
+resubmission or Build restoration. No receipt can be recorded if no response headers arrive.
+
+`hypit doctor` reads the authenticated model
 catalog to verify configured capabilities; ordinary preflight never makes that request. The package
 declares HypiHub's public pricing page, `https://hypit.ai/commercial/pricing/`, as its price source.
 For each selected Need, `readPricing` resolves the corresponding HypiHub model and returns the service's

package/packages/provider-hypihub/src/oauth.ts

@@ -65,7 +65,7 @@ export function createHypiHubAuth(options: {
       throw new Error("HypiHub OAuth credential is read-only; run hypit auth login with a writable Credential Store");
     }
     refreshing = (async () => {
-      const deadline = requestDeadline(options.requestTimeoutMs);
+      const deadline = requestDeadline(options.requestTimeoutMs, () => new Error("HypiHub OAuth refresh timed out"));
       try {
         const response = await deadline.wait(options.fetch(tokenEndpoint, {
           method: "POST",

package/packages/provider-hypihub/src/provider.ts

@@ -100,12 +100,14 @@ class HypiHubHttpError extends Error {
 class HypiHubClient {
   readonly baseUrl: string;
   readonly timeout: number;
+  readonly oauthTimeout: number;
   readonly downloadAttempts: number;
   readonly fetcher: typeof globalThis.fetch;
   readonly uploader: HypiHubUploader;
   constructor(options: {
     readonly baseUrl: string;
     readonly timeout: number;
+    readonly oauthTimeout: number;
     readonly uploadConcurrency: number;
     readonly uploadPartTimeout: number;
     readonly uploadPartAttempts: number;
@@ -114,6 +116,7 @@ class HypiHubClient {
   }) {
     this.baseUrl = options.baseUrl.replace(/\/$/u, "");
     this.timeout = options.timeout;
+    this.oauthTimeout = options.oauthTimeout;
     this.downloadAttempts = options.downloadAttempts;
     this.fetcher = options.fetcher;
     this.uploader = new HypiHubUploader({
@@ -125,14 +128,18 @@ class HypiHubClient {
       fetch: this.fetcher,
     });
   }
-  async json(path: string, auth: HypiHubAuth, init: RequestInit = {}, refreshOnUnauthorized = true): Promise<Record<string, unknown>> {
+  async json(path: string, auth: HypiHubAuth, init: RequestInit = {}, refreshOnUnauthorized = true,
+    onResponse?: (response: Response) => Promise<void>): Promise<Record<string, unknown>> {
+    const token = await auth.token();
     const deadline = requestDeadline(this.timeout);
     try {
-      const response = await deadline.wait(this.fetcher(`${this.baseUrl}${path}`, { ...init, signal: deadline.signal, headers: { authorization: `Bearer ${await auth.token()}`, ...(init.headers ?? {}) } }));
+      const response = await deadline.wait(this.fetcher(`${this.baseUrl}${path}`, { ...init, signal: deadline.signal, headers: { authorization: `Bearer ${token}`, ...(init.headers ?? {}) } }));
+      if (response.status !== 401 && onResponse !== undefined) await deadline.wait(onResponse(response));
       const text = await deadline.wait(response.text()); let body: unknown = {};
       if (response.status === 401 && refreshOnUnauthorized && auth.canRefresh()) {
+        deadline.finish();
         await auth.refresh();
-        return await this.json(path, auth, init, false);
+        return await this.json(path, auth, init, false, onResponse);
       }
       if (!response.ok) throw new HypiHubHttpError(response.status, `HypiHub returned HTTP ${response.status}: ${text.slice(0, 300)}`);
       try { body = text.length === 0 ? {} : JSON.parse(text); } catch { throw new Error(`HypiHub returned invalid JSON (${response.status})`); }
@@ -165,24 +172,40 @@ class HypiHubClient {
       ...(personReference === undefined ? {} : { isPersonReference: personReference }) }, auth);
   }
 
-  async transcribe(body: Record<string, unknown>, auth: HypiHubAuth): Promise<Record<string, unknown>> {
+  async transcribe(body: Record<string, unknown>, auth: HypiHubAuth,
+    report?: (message: string) => Promise<void>): Promise<Record<string, unknown>> {
     return await this.json("/audio/transcriptions", auth, {
       method: "POST",
       headers: { "content-type": "application/json" },
       body: JSON.stringify(body),
+    }, true, async (response) => {
+      const requestId = response.headers.get("x-request-id");
+      if (requestId === null || !/^[A-Za-z0-9_-]{1,200}$/u.test(requestId)) return;
+      let retrieval = "";
+      const location = response.headers.get("location");
+      if (location !== null) {
+        try {
+          const url = new URL(location, this.baseUrl);
+          const expected = new URL(`${this.baseUrl}/audio/transcriptions/${encodeURIComponent(requestId)}`);
+          if (url.href === expected.href) retrieval = `; result lookup: ${url.href}`;
+        } catch { /* A malformed Location does not erase the request identifier. */ }
+      }
+      await report?.(`HypiHub transcription request ${requestId} (HTTP ${response.status})${retrieval}`);
     });
   }
   async speech(auth: HypiHubAuth, body: Record<string, unknown>, refreshOnUnauthorized = true): Promise<readonly { readonly bytes: Uint8Array; readonly mediaType: string }[]> {
+    const token = await auth.token();
     const deadline = requestDeadline(this.timeout);
     try {
       const response = await deadline.wait(this.fetcher(`${this.baseUrl}/audio/speech`, {
         method: "POST",
-        headers: { authorization: `Bearer ${await auth.token()}`, "content-type": "application/json" },
+        headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
         body: JSON.stringify({ ...body, output: "b64_json" }),
         signal: deadline.signal,
       }));
       const bytes = new Uint8Array(await deadline.wait(response.arrayBuffer()));
       if (response.status === 401 && refreshOnUnauthorized && auth.canRefresh()) {
+        deadline.finish();
         await auth.refresh();
         return await this.speech(auth, body, false);
       }
@@ -226,7 +249,7 @@ function authFor(context: EndpointInvocationContext, client: HypiHubClient): Hyp
   return createHypiHubAuth({
     credential: credential(context.credentials),
     baseUrl: client.baseUrl,
-    requestTimeoutMs: client.timeout,
+    requestTimeoutMs: client.oauthTimeout,
     fetch: client.fetcher,
   });
 }
@@ -235,7 +258,7 @@ function pricingAuth(credentials: Readonly<Record<string, EndpointCredential>>,
   return createHypiHubAuth({
     credential: credential(credentials),
     baseUrl: client.baseUrl,
-    requestTimeoutMs: client.timeout,
+    requestTimeoutMs: client.oauthTimeout,
     fetch: client.fetcher,
   });
 }
@@ -311,6 +334,7 @@ export async function diagnoseHypiHubProvider(
   const client = new HypiHubClient({
     baseUrl: apiBaseUrl(options.baseUrl ?? "https://hypit.ai/v1"),
     timeout: options.requestTimeoutMs ?? 30_000,
+    oauthTimeout: options.oauthRequestTimeoutMs ?? 30_000,
     uploadConcurrency: options.uploadConcurrency ?? 8,
     uploadPartTimeout: options.uploadPartTimeoutMs ?? 5 * 60_000,
     uploadPartAttempts: options.uploadPartAttempts ?? 3,
@@ -320,7 +344,7 @@ export async function diagnoseHypiHubProvider(
   const auth = createHypiHubAuth({
     credential: { secret: apiKey },
     baseUrl: client.baseUrl,
-    requestTimeoutMs: client.timeout,
+    requestTimeoutMs: client.oauthTimeout,
     fetch: client.fetcher,
   });
   const response = await client.json("/models", auth);
@@ -487,6 +511,7 @@ export function createHypiHubProvider(options: CreateHypiHubProviderOptions = {}
   const client = new HypiHubClient({
     baseUrl: apiBaseUrl(options.baseUrl ?? "https://hypit.ai/v1"),
     timeout: requestTimeoutMs,
+    oauthTimeout: oauthRequestTimeoutMs,
     uploadConcurrency: options.uploadConcurrency ?? 8,
     uploadPartTimeout: uploadPartTimeoutMs,
     uploadPartAttempts,
@@ -496,6 +521,7 @@ export function createHypiHubProvider(options: CreateHypiHubProviderOptions = {}
   const pricingClient = new HypiHubClient({
     baseUrl: apiBaseUrl(options.baseUrl ?? "https://hypit.ai/v1"),
     timeout: pricingRequestTimeoutMs,
+    oauthTimeout: oauthRequestTimeoutMs,
     uploadConcurrency: options.uploadConcurrency ?? 8,
     uploadPartTimeout: uploadPartTimeoutMs,
     uploadPartAttempts,
@@ -531,7 +557,7 @@ export function createHypiHubProvider(options: CreateHypiHubProviderOptions = {}
         response_format: "verbose_json",
         language: request.language,
         timestamp_granularities: ["segment", "word"],
-      }, auth);
+      }, auth, async (message) => { await context.reportDiagnostic?.({ level: "info", message }); });
       const evidence = sealAlignedTranscriptEvidence({
         passages: interpretWhisperXTranscript(response as WhisperXTranscriptResponse, request.sampleFrames),
       });

package/packages/provider-hypihub/src/upload.ts

@@ -120,7 +120,7 @@ async function acquireUploadSlot(origin: string, auth: UploadAuth, limit: number
   };
 }
 
-/** Uploads media through HypiHub's session-negotiated private regional S3 multipart flow. */
+/** Uploads media using the transfer mode negotiated by the selected HypiHub service. */
 export class HypiHubUploader {
   readonly baseUrl: string;
   readonly requestTimeout: number;
@@ -179,16 +179,18 @@ export class HypiHubUploader {
   }
 
   private async jsonOnce(path: string, auth: UploadAuth, init: RequestInit, timeoutMs: number, retryAuth = true): Promise<Record<string, unknown>> {
+    const token = await uploadToken(auth);
     const request = requestDeadline(timeoutMs);
     const deadline = Date.now() + timeoutMs;
     try {
       const response = await request.wait(this.fetcher(`${this.baseUrl}${path}`, {
         ...init,
         signal: request.signal,
-        headers: { authorization: `Bearer ${await uploadToken(auth)}`, ...(init.headers ?? {}) },
+        headers: { authorization: `Bearer ${token}`, ...(init.headers ?? {}) },
       }));
       const text = await request.wait(response.text());
       if (response.status === 401 && retryAuth && uploadCanRefresh(auth)) {
+        request.finish();
         await (auth as HypiHubAuth).refresh();
         return await this.jsonOnce(path, auth, init, Math.max(1, deadline - Date.now()), false);
       }
@@ -214,6 +216,16 @@ export class HypiHubUploader {
   }
 
   private async signParts(uploadId: string, declarations: readonly PartDeclaration[], auth: UploadAuth): Promise<Map<number, Record<string, unknown>>> {
+    // HypiHub accepts at most 128 part declarations per signing request.
+    if (declarations.length > 128) {
+      const signed = new Map<number, Record<string, unknown>>();
+      for (let offset = 0; offset < declarations.length; offset += 128) {
+        for (const [number, part] of await this.signParts(uploadId, declarations.slice(offset, offset + 128), auth)) {
+          signed.set(number, part);
+        }
+      }
+      return signed;
+    }
     const startedAt = Date.now();
     this.log(`part signing started upload=${uploadId} parts=${declarations.length}`);
     const response = await this.json(`/files/uploads/${encodeURIComponent(uploadId)}/parts`, auth, {
@@ -396,9 +408,30 @@ export class HypiHubUploader {
       this.log(`upload session request failed elapsed=${this.elapsed(policyStartedAt)} reason=${this.safeReason(error)}`);
       throw error;
     }
-    assert(policy.upload_mode === "s3_multipart", "HypiHub returned an unknown upload mode");
-    const result = await this.uploadDirect(input.bytes, auth, policy);
+    assert(policy.upload_mode === "s3_multipart" || policy.upload_mode === "api_multipart",
+      "HypiHub returned an unknown upload mode");
+    const result = policy.upload_mode === "api_multipart"
+      ? await this.uploadApi(input, auth, policy)
+      : await this.uploadDirect(input.bytes, auth, policy);
     this.log(`upload finished bytes=${input.bytes.byteLength} mime=${input.mediaType} elapsed=${this.elapsed(startedAt)}`);
     return result;
   }
+
+  private async uploadApi(input: HypiHubUploadInput, auth: UploadAuth, policy: Record<string, unknown>): Promise<string> {
+    const endpoint = new URL(requiredString(policy.endpoint, "HypiHub file upload endpoint"), this.baseUrl);
+    assert(endpoint.href === `${this.baseUrl}/files`, "HypiHub file upload endpoint must belong to the selected service");
+    if (policy.max_bytes !== undefined) {
+      assert(input.bytes.byteLength <= requiredInteger(policy.max_bytes, "HypiHub file upload byte limit"),
+        "HypiHub reference exceeds the negotiated file upload byte limit");
+    }
+    const form = new FormData();
+    form.set("file", new Blob([new Uint8Array(input.bytes)], { type: input.mediaType }),
+      input.filename ?? `reference.${extension(input.mediaType)}`);
+    form.set("purpose", input.purpose ?? "reference");
+    if (input.isPersonReference !== undefined) form.set("is_person_reference", String(input.isPersonReference));
+    const response = await this.json("/files", auth, { method: "POST", body: form });
+    const url = requiredString(response.url, "HypiHub file upload URL");
+    assertHTTPS(url, "HypiHub file upload URL");
+    return url;
+  }
 }

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);
         }