@hypit/hypit 0.1.3 → 0.1.5

package/packages/deck-track/README.md

@@ -1,7 +1,7 @@
 # `@hypit/deck-track`
 
-The Track Surface accepts `semantic={speech.semantic}` or `space={animation}`. Semantic context
-resolves Script Selections and Moments; authored space supports clock-based animation. Shared `at`
+The Track Surface accepts `timeline={program.timeline}`. The same Timeline supports authored
+positions and, where prepared Takes supply evidence, Script Selections and Moments. Shared `at`
 inputs accept a Moment or a time such as `2s`; `at` with `for` produces a Window where required.
 
 The official, deliberately narrow depth-stack Deck author package.
@@ -19,7 +19,7 @@ Media layer lowerer, but Deck is not a Media mode and exports only an ordinary p
 
 <deck:DepthStack
   id="proof-stack"
-  semantic={speech.semantic}
+  timeline={speech.timeline}
   canvas={vertical}
   frame={layout.proof-stack}
   until={story.selection.proof}

package/packages/deck-track/package.json

@@ -20,7 +20,7 @@
     "@hypit/narrative": "workspace:*",
     "@hypit/program-space": "workspace:*",
     "@hypit/protocol": "workspace:*",
-    "@hypit/semantic-track": "workspace:*",
+    "@hypit/timeline": "workspace:*",
     "@hypit/spatial": "workspace:*",
     "@hypit/svs": "workspace:*",
     "@hypit/temporal": "workspace:*",

package/packages/deck-track/src/component.ts

@@ -1,7 +1,7 @@
+import type { Timeline } from "@hypit/timeline";
 import type { ComponentPackage, ProducerHandlerContext } from "@hypit/component-kit";
 import { canonicalize } from "@hypit/protocol";
 import type { StoredValue } from "@hypit/protocol";
-import type { ProgramSpace } from "@hypit/program-space";
 import type { CanvasSpace, SpatialFrame } from "@hypit/spatial";
 import type { TemporalInstant } from "@hypit/temporal";
 import type { MediaLayerSet } from "@hypit/media-track";
@@ -32,7 +32,7 @@ function finalizeInputs(inputs: ProducerHandlerContext["inputs"]) {
     header: inline<DepthStackHeader>(inputs.header?.value, "DepthStackHeader"),
     frame: inline<SpatialFrame>(inputs.frame?.value, "SpatialFrame"),
     spec: inline<DepthStackSpec>(inputs.spec?.value, "DepthStackSpec"),
-    space: inline<ProgramSpace>(inputs.space?.value, "ProgramSpace"),
+    timeline: inline<Timeline>(inputs.timeline?.value, "Timeline"),
   };
 }
 
@@ -53,7 +53,7 @@ export const depthStackComponent = {
       producer: depthStackProducers.appendCard,
       handler: ({ inputs }) => ({ outputs: { set: output(appendDepthStackCard(
         inline<DepthStackCardSet>(inputs.set?.value, "DepthStackCardSet"),
-        inline<ProgramSpace>(inputs.space?.value, "ProgramSpace"),
+        inline<Timeline>(inputs.timeline?.value, "Timeline"),
         inline<MediaLayerSet>(inputs.material?.value, "MediaLayerSet"),
         inline<DepthStackCardLabel>(inputs.label?.value, "DepthStackCardLabel"),
         inline<DepthStackCardSpec>(inputs.spec?.value, "DepthStackCardSpec"),
@@ -66,7 +66,7 @@ export const depthStackComponent = {
         const value = finalizeInputs(inputs);
         return { outputs: { program: output(finalizeDepthStack(
           value.set, value.header, value.frame, value.spec,
-          inline<TemporalInstant>(inputs.terminal?.value, "TemporalInstant"), value.space,
+          inline<TemporalInstant>(inputs.terminal?.value, "TemporalInstant"), value.timeline,
         )) }, needs: {} };
       },
     },
@@ -74,7 +74,7 @@ export const depthStackComponent = {
       producer: depthStackProducers.render,
       handler: ({ inputs }) => ({ outputs: { track: output(renderDepthStack(
         inline<CanvasSpace>(inputs.canvas?.value, "CanvasSpace"),
-        inline<ProgramSpace>(inputs.space?.value, "ProgramSpace"),
+        inline<Timeline>(inputs.timeline?.value, "Timeline"),
         inline<DepthStackProgram>(inputs.program?.value, "DepthStackProgram"),
       )) }, needs: {} }),
     },

package/packages/deck-track/src/fragment.ts

@@ -1,4 +1,5 @@
-import { programSpaceTypes } from "@hypit/program-space";
+import { timelineTypes } from "@hypit/timeline";
+
 import { artifactTypes } from "@hypit/artifact";
 import { compositionTypes } from "@hypit/composition";
 import { sealGraphFragment } from "@hypit/elaborator";
@@ -42,7 +43,7 @@ export function createDepthStackFragment(
     { name: "canvas", type: spatialTypes.canvas },
     { name: "frame", type: spatialTypes.frame },
     { name: "header", type: depthStackTypes.header },
-    { name: "space", type: programSpaceTypes.programSpace },
+    { name: "timeline", type: timelineTypes.track },
     { name: "spec", type: depthStackTypes.spec },
   ];
   const operations: FragmentOperation[] = [
@@ -107,7 +108,7 @@ export function createDepthStackFragment(
       producer: depthStackProducers.appendCard,
       inputs: {
         set: cardSet,
-        space: input("space"),
+        timeline: input("timeline"),
         material: operation(sampleId),
         label: input(card.labelName),
         spec: input(card.cardSpecName),
@@ -126,7 +127,7 @@ export function createDepthStackFragment(
       header: input("header"),
       frame: input("frame"),
       spec: input("spec"),
-      space: input("space"),
+      timeline: input("timeline"),
       terminal: input(terminalName),
     },
     result: { kind: "output", name: "program" },
@@ -134,7 +135,7 @@ export function createDepthStackFragment(
   operations.push({
     id: "track",
     producer: depthStackProducers.render,
-    inputs: { canvas: input("canvas"), space: input("space"), program: operation("program") },
+    inputs: { canvas: input("canvas"), timeline: input("timeline"), program: operation("program") },
     result: { kind: "output", name: "track" },
   });
   return sealGraphFragment({

package/packages/deck-track/src/lower.ts

@@ -1,3 +1,4 @@
+import type { Timeline } from "@hypit/timeline";
 import {
   assertVisualTrackIdentity,
   sealVisualTrack,
@@ -20,7 +21,6 @@ import type {
   MediaSampleLayerProgram,
   MediaVisualTrim,
 } from "@hypit/media-track";
-import type { ProgramSpace } from "@hypit/program-space";
 import { assertCanvasSpace } from "@hypit/spatial";
 import type { CanvasSpace, SpatialFrame } from "@hypit/spatial";
 
@@ -170,17 +170,17 @@ function samplingFor(input: {
   readonly relation: number;
   readonly stageStart: number;
   readonly stageDuration: number;
-  readonly space: ProgramSpace;
+  readonly timeline: Timeline;
 }): VisualTimedSampling | undefined {
   const timing = sourceTiming(input.layer);
   if (timing === undefined) return undefined;
-  assert(timing.frameRate.numerator === input.space.frameRate.numerator
-    && timing.frameRate.denominator === input.space.frameRate.denominator,
-  `DepthStack Card ${input.card.id} timed material must be normalized to ProgramSpace.`);
+  assert(timing.frameRate.numerator === input.timeline.frameRate.numerator
+    && timing.frameRate.denominator === input.timeline.frameRate.denominator,
+  `DepthStack Card ${input.card.id} timed material must be normalized to Timeline.`);
   const trim = trimFor(input.layer, timing.frameCount);
   if (input.relation === 0) {
     return resolveVisualSampling({
-      space: input.space,
+      timeline: input.timeline,
       sourceFrameRate: timing.frameRate,
       sourceFrameCount: timing.frameCount,
       targetFrameCount: input.stageDuration,
@@ -282,10 +282,10 @@ function labelElement(card: DepthStackCard, parent: string, order: number): Visu
 
 export function renderDepthStack(
   canvas: CanvasSpace,
-  space: ProgramSpace,
+  timeline: Timeline,
   program: DepthStackProgram,
 ): VisualTrack {
-  assertDepthStackProgramIdentity(program, space);
+  assertDepthStackProgramIdentity(program, timeline);
   assertCanvasSpace(canvas);
   const presents: VisualTrack["presents"][number][] = [];
   for (let stageIndex = 0; stageIndex < program.cards.length; stageIndex += 1) {
@@ -322,7 +322,7 @@ export function renderDepthStack(
       const samplingAnimationOverrides: Record<string, VisualAnimation | null> = {};
       for (const layer of card.material.layers) {
         if (layer.kind !== "sample") continue;
-        const sampling = samplingFor({ program, card, layer, relation, stageStart, stageDuration, space });
+        const sampling = samplingFor({ program, card, layer, relation, stageStart, stageDuration, timeline });
         if (sampling !== undefined) samplingOverrides[layer.id] = sampling;
         if (relation !== 0 && layer.samplingMotion !== undefined) samplingAnimationOverrides[layer.id] = null;
       }
@@ -337,7 +337,7 @@ export function renderDepthStack(
         stacking: { order: 0, tieBreak: card.id },
         sounds: [],
       };
-      const material = [...lowerMediaItemElements(mediaItem, space, {
+      const material = [...lowerMediaItemElements(mediaItem, timeline, {
         placementParent: group.poseParent,
         lifecycleAnimationOverride: null,
         samplingOverrides,
@@ -360,11 +360,11 @@ export function renderDepthStack(
     }
   }
   const track = sealVisualTrack({
-    programSpaceId: space.id,
+    programSpaceId: timeline.id,
     visualIr: "hypit.visual-ir@1",
     id: program.id,
     presents,
   });
-  assertVisualTrackIdentity(track, space);
+  assertVisualTrackIdentity(track, timeline);
   return track;
 }

package/packages/deck-track/src/manifest.ts

@@ -1,3 +1,4 @@
+import { timelineTypes } from "@hypit/timeline";
 import { temporalContextAttributeVocabulary } from "@hypit/temporal-markup";
 import { readFile } from "node:fs/promises";
 
@@ -19,9 +20,9 @@ import {
   mediaTrackTypes,
 } from "@hypit/media-track";
 import { narrativeDependency, narrativeTypes } from "@hypit/narrative";
-import { programSpaceDependency, programSpaceTypes } from "@hypit/program-space";
+
 import type { ModuleManifest, ProducerRef, TypeRef, ValueSchema } from "@hypit/protocol";
-import { semanticTrackDependency } from "@hypit/semantic-track";
+import { timelineDependency } from "@hypit/timeline";
 import { spatialDependency, spatialFrameSchema, spatialTypes } from "@hypit/spatial";
 import { svsRecipeType } from "@hypit/svs";
 import { temporalDependency, temporalTypes } from "@hypit/temporal";
@@ -118,7 +119,7 @@ export const depthStackProgramSchema: ValueSchema = object({
 const finalizeInputs = [
   { name: "set", type: depthStackTypes.cardSet }, { name: "header", type: depthStackTypes.header },
   { name: "frame", type: spatialTypes.frame }, { name: "spec", type: depthStackTypes.spec },
-  { name: "space", type: programSpaceTypes.programSpace },
+  { name: "timeline", type: timelineTypes.track },
 ] as const;
 
 export const depthStackMarkupSurfaces = [
@@ -386,7 +387,7 @@ export const depthStackMarkupSurfaces = [
         ],
         example: `<deck:DepthStack
   id="proof-stack"
-  semantic={speech.semantic}
+  timeline={speech.timeline}
   canvas={vertical}
   frame={layout.proof-stack}
   until={story.selection.proof}
@@ -408,7 +409,7 @@ export const depthStackMarkupSurfaces = [
 
 export const depthStackManifest: ModuleManifest = {
   format: "hypit.module@1", name: depthStackModuleRef.name, version: depthStackModuleRef.version,
-  dependencies: [narrativeDependency, programSpaceDependency, semanticTrackDependency, spatialDependency, temporalDependency, mediaDependency, mediaTrackDependency, compositionDependency, textDependency],
+  dependencies: [narrativeDependency, timelineDependency, spatialDependency, temporalDependency, mediaDependency, mediaTrackDependency, compositionDependency, textDependency],
   types: [
     { name: depthStackTypes.header.name },
     { name: depthStackTypes.spec.name },
@@ -422,7 +423,7 @@ export const depthStackManifest: ModuleManifest = {
     { name: depthStackProducers.bindLabelText.name, inputs: [{ name: "style", type: depthStackTypes.cardLabelStyle }, { name: "content", type: textTypes.text }], outputs: [{ name: "label", type: depthStackTypes.cardLabel }], needs: [] },
     { name: depthStackProducers.createCards.name, inputs: [], outputs: [{ name: "set", type: depthStackTypes.cardSet }], needs: [] },
     { name: depthStackProducers.appendCard.name, inputs: [
-      { name: "set", type: depthStackTypes.cardSet }, { name: "space", type: programSpaceTypes.programSpace }, { name: "material", type: mediaTrackTypes.layerSet },
+      { name: "set", type: depthStackTypes.cardSet }, { name: "timeline", type: timelineTypes.track }, { name: "material", type: mediaTrackTypes.layerSet },
       { name: "label", type: depthStackTypes.cardLabel }, { name: "spec", type: depthStackTypes.cardSpec },
       { name: "activation", type: temporalTypes.instant },
     ], outputs: [{ name: "set", type: depthStackTypes.cardSet }], needs: [] },
@@ -430,7 +431,7 @@ export const depthStackManifest: ModuleManifest = {
       inputs: [...finalizeInputs, { name: "terminal", type: temporalTypes.instant }],
       outputs: [{ name: "program", type: depthStackTypes.program }], needs: [] },
     { name: depthStackProducers.render.name, inputs: [
-      { name: "canvas", type: spatialTypes.canvas }, { name: "space", type: programSpaceTypes.programSpace },
+      { name: "canvas", type: spatialTypes.canvas }, { name: "timeline", type: timelineTypes.track },
       { name: "program", type: depthStackTypes.program },
     ], outputs: [{ name: "track", type: compositionTypes.visualTrack }], needs: [] },
   ],

package/packages/deck-track/src/program.ts

@@ -1,3 +1,4 @@
+import type { Timeline } from "@hypit/timeline";
 import {
   assertFontArtifactRef,
 } from "@hypit/media";
@@ -6,11 +7,7 @@ import {
   assertMediaLayerSet,
   assertMediaLifecycleMotion,
 } from "@hypit/media-track";
-import {
-  assertProgramSpaceIdentity,
-  programSpaceFrameCount,
-} from "@hypit/program-space";
-import type { ProgramSpace } from "@hypit/program-space";
+import { assertProgramSpaceIdentity, programSpaceFrameCount } from "@hypit/program-space";
 import { canonicalize } from "@hypit/protocol";
 import { verifyText } from "@hypit/text";
 import type { Text } from "@hypit/text";
@@ -229,13 +226,13 @@ function appendDepthStackCardAtFrame(
 
 export function appendDepthStackCard(
   set: DepthStackCardSet,
-  space: ProgramSpace,
+  timeline: Timeline,
   material: DepthStackCardSet["cards"][number]["material"],
   label: DepthStackCardLabel,
   spec: DepthStackCardSpec,
   activation: TemporalInstant,
 ): DepthStackCardSet {
-  assertTemporalInstantFor(activation, { subjectId: spec.id, space });
+  assertTemporalInstantFor(activation, { subjectId: spec.id, space: timeline });
   return appendDepthStackCardAtFrame(set, material, label, spec, activation.frame);
 }
 
@@ -245,13 +242,13 @@ function finalizeDepthStackAtFrame(
   frame: SpatialFrame,
   spec: DepthStackSpec,
   terminalFrame: number,
-  space: ProgramSpace,
+  timeline: Timeline,
 ): DepthStackProgram {
   assertDepthStackCardSet(set);
   assertDepthStackHeader(header);
   assertSpatialFrame(frame);
   assertDepthStackSpec(spec);
-  assertProgramSpaceIdentity(space);
+  assertProgramSpaceIdentity(timeline);
   assert(set.cards.length > 0, "DepthStack requires at least one Card.");
   const first = set.cards[0]!;
   const program: DepthStackProgram = {
@@ -263,7 +260,7 @@ function finalizeDepthStackAtFrame(
     spec: structuredClone(spec),
     cards: structuredClone(set.cards),
   };
-  assertDepthStackProgramIdentity(program, space);
+  assertDepthStackProgramIdentity(program, timeline);
   return canonicalize(program) as unknown as DepthStackProgram;
 }
 
@@ -273,10 +270,10 @@ export function finalizeDepthStack(
   frame: SpatialFrame,
   spec: DepthStackSpec,
   terminal: TemporalInstant,
-  space: ProgramSpace,
+  timeline: Timeline,
 ): DepthStackProgram {
-  assertTemporalInstantFor(terminal, { subjectId: header.id, space });
-  return finalizeDepthStackAtFrame(set, header, frame, spec, terminal.frame, space);
+  assertTemporalInstantFor(terminal, { subjectId: header.id, space: timeline });
+  return finalizeDepthStackAtFrame(set, header, frame, spec, terminal.frame, timeline);
 }
 
 export function assertDepthStackProgram(program: DepthStackProgram): void {
@@ -307,10 +304,10 @@ export function assertDepthStackProgram(program: DepthStackProgram): void {
   }
 }
 
-export function assertDepthStackProgramIdentity(program: DepthStackProgram, space: ProgramSpace): void {
-  assertProgramSpaceIdentity(space);
+export function assertDepthStackProgramIdentity(program: DepthStackProgram, timeline: Timeline): void {
+  assertProgramSpaceIdentity(timeline);
   assertDepthStackProgram(program);
-  assert(program.terminalFrame <= programSpaceFrameCount(space), "DepthStack terminal is outside ProgramSpace.");
+  assert(program.terminalFrame <= programSpaceFrameCount(timeline), "DepthStack terminal is outside Timeline.");
 }
 
 function modulo(value: number, size: number): number {

package/packages/deck-track/src/surface.ts

@@ -1,4 +1,4 @@
-import { createTemporalSpace, resolveTemporalContext } from "@hypit/temporal-markup";
+import { resolveTemporalContext } from "@hypit/temporal-markup";
 import { artifactTypes } from "@hypit/artifact";
 import { mediaTypes } from "@hypit/media";
 import type { FontStackRef } from "@hypit/media";
@@ -181,28 +181,27 @@ export const decodeDepthStackLabelSurface: StructuredSurfaceHandler = ({ element
 };
 
 export const decodeDepthStackSurface: StructuredSurfaceHandler = ({ element, resolveReference }) => {
-  allowed(element, ["id", "semantic", "space", "canvas", "frame", "appearance", "until", "until-boundary"]);
+  allowed(element, ["id", "timeline", "canvas", "frame", "appearance", "until", "until-boundary"]);
   const id = text(element, "id");
   const context = resolveTemporalContext({ element, resolveReference });
-  const time = createTemporalSpace({ id: id, element, ...context });
   const canvas = reference(element.attributes.canvas, `${element.name}.canvas`, spatialTypes.canvas, resolveReference);
   const frame = reference(element.attributes.frame, `${element.name}.frame`, spatialTypes.frame, resolveReference);
   const appearance = recipe(element.attributes.appearance, `${element.name}.appearance`, resolveReference);
   const terminal = createTemporalInstantProjection({
-    id: `${id}.terminal`, subjectId: id, element, ...context, space: time.space, resolveReference,
+    id: `${id}.terminal`, subjectId: id, element, ...context, resolveReference,
     semanticAttribute: "until", boundaryAttribute: "until-boundary", boundaryFallback: "end", projectedAttribute: false,
   });
   const records: SurfaceRecordDraft[] = [...terminal.records];
-  const temporalComponents: SurfaceComponentDraft[] = [...time.components, ...terminal.components];
-  const temporalFragments = [...time.fragments, ...terminal.fragments];
+  const temporalComponents: SurfaceComponentDraft[] = [...terminal.components];
+  const temporalFragments = [...terminal.fragments];
   const headerId = `${id}.header`;
   const specId = `${id}.spec`;
   records.push(
     { id: headerId, type: depthStackTypes.header, value: { kind: "inline", value: sealDepthStackHeader({ id }) }, range: element.range },
     { id: specId, type: depthStackTypes.spec, value: { kind: "inline", value: decodeDepthStackSpec(appearance) }, range: element.range },
   );
-  const inputs: Record<string, typeof time.space.ref> = {
-    canvas: canvas.ref, frame: frame.ref, header: { kind: "record", id: headerId }, space: time.space.ref,
+  const inputs: Record<string, typeof context.timeline.ref> = {
+    canvas: canvas.ref, frame: frame.ref, header: { kind: "record", id: headerId }, timeline: context.timeline.ref,
     spec: { kind: "record", id: specId }, terminal: terminal.ref,
   };
   const cards: DepthStackFragmentCard[] = [];
@@ -225,7 +224,7 @@ export const decodeDepthStackSurface: StructuredSurfaceHandler = ({ element, res
       : reference(child.attributes.extent, `${child.name}.extent`, spatialTypes.extent, resolveReference);
     if (sourceKind === "still" && extent === undefined) throw new Error(`${child.name}.extent is required for a still image.`);
     if (sourceKind !== "still" && extent !== undefined) throw new Error(`${child.name}.extent belongs only to a still image.`);
-    const activation = createTemporalInstantProjection({ id: `${id}.${cardId}`, subjectId: cardId, element: child, ...context, space: time.space, resolveReference });
+    const activation = createTemporalInstantProjection({ id: `${id}.${cardId}`, subjectId: cardId, element: child, ...context, resolveReference });
     records.push(...activation.records); temporalComponents.push(...activation.components); temporalFragments.push(...activation.fragments);
     const cardAppearance = child.attributes.appearance === undefined
       ? appearance : recipe(child.attributes.appearance, `${child.name}.appearance`, resolveReference);
@@ -249,7 +248,7 @@ export const decodeDepthStackSurface: StructuredSurfaceHandler = ({ element, res
     inputs[sampleSpecName] = { kind: "record", id: sampleId };
     inputs[cardSpecName] = { kind: "record", id: cardSpecId };
     inputs[activationName] = activation.ref;
-    let labelRef: typeof time.space.ref;
+    let labelRef: typeof context.timeline.ref;
     if (child.attributes.label === undefined) {
       const labelId = `${id}.card.${suffix}.label-none`;
       records.push({ id: labelId, type: depthStackTypes.cardLabel, value: { kind: "inline", value: noDepthStackCardLabel() }, range: child.range });

package/packages/driver-node/src/driver.ts

@@ -337,6 +337,22 @@ export class NodeDriver {
     operation: OperationSnapshot,
     registration: EndpointRegistration,
     runtimeContext: RuntimeExecutionContext,
+  ): Promise<OperationSnapshot> {
+    const result = await this.#advanceOperationStep(operation, registration, runtimeContext);
+    if (result.status === "failed" && operation.status !== "failed") {
+      await runtimeContext.recordExecution?.({ endpoint: operation.endpoint, kind: "failed", message: result.failure!.message });
+    } else if (result.completion !== undefined && operation.completion === undefined) {
+      await runtimeContext.recordExecution?.({ endpoint: operation.endpoint, kind: "completed" });
+    } else if (result.progress?.phase !== undefined && result.progress.phase !== operation.progress?.phase) {
+      await runtimeContext.recordExecution?.({ endpoint: operation.endpoint, kind: "phase", phase: result.progress.phase });
+    }
+    return result;
+  }
+
+  async #advanceOperationStep(
+    operation: OperationSnapshot,
+    registration: EndpointRegistration,
+    runtimeContext: RuntimeExecutionContext,
   ): Promise<OperationSnapshot> {
     const operations = this.operations!;
     if (registration.kind !== "asynchronous") throw new Error("Operation Endpoint is not asynchronous");
@@ -358,6 +374,10 @@ export class NodeDriver {
         command: structuredClone(command), need: structuredClone(command.need),
         resources: this.#resourceStore(operation.build), operation: operation.id,
         credentials: await this.#endpointCredentials({ ...registration, credentials: operation.credentials ?? registration.credentials ?? {} }),
+        ...(runtimeContext.recordExecution === undefined ? {} : {
+          reportDiagnostic: (diagnostic: import("@hypit/runtime").ExecutionDiagnostic) =>
+            runtimeContext.recordExecution!({ endpoint: operation.endpoint, kind: "diagnostic", ...diagnostic }),
+        }),
         checkpoint: async (checkpoint: import("@hypit/endpoint-kit").EndpointCheckpoint) => {
           await operations.update(operation.id, { status: "pending", ...checkpoint,
             submission: "accepted", acknowledgedAt: operation.acknowledgedAt ?? Date.now(), wakeAt: Date.now(), progress: { phase: checkpoint.remoteEnded ? "collecting" : "submitted" } });
@@ -366,10 +386,12 @@ export class NodeDriver {
       };
       if (action === "submit") {
         await operations.update(operation.id, { status: "pending", submission: "started", progress: { phase: "submitting" } });
+        await runtimeContext.recordExecution?.({ endpoint: operation.endpoint, kind: "started" });
         return await endpoint.start(context);
       }
       const pollContext = { ...context, handle: structuredClone(operation.handle!) };
       if (action === "collect") {
+        await runtimeContext.recordExecution?.({ endpoint: operation.endpoint, kind: "phase", phase: "collecting" });
         if (endpoint.collect === undefined) throw new Error(`Endpoint ${registration.id} declared artifacts ready but has no collect action`);
         return await endpoint.collect(pollContext);
       }
@@ -418,13 +440,13 @@ export class NodeDriver {
     });
   }
 
-  async advanceOperation(operation: OperationSnapshot): Promise<OperationSnapshot> {
+  async advanceOperation(operation: OperationSnapshot, context?: RuntimeExecutionContext): Promise<OperationSnapshot> {
     if (operation.request === undefined) throw new Error(`Operation ${operation.id} has no stored request`);
     const selected = this.endpoints.resolve(operation.request.need);
     if (selected.status !== "resolved" || selected.registration.id !== operation.endpoint) {
       throw new Error(`Operation ${operation.id} cannot change its selected Endpoint ${operation.endpoint}`);
     }
-    return await this.#advanceOperation(operation, selected.registration, { build: operation.build });
+    return await this.#advanceOperation(operation, selected.registration, context ?? { build: operation.build });
   }
 
   async #execute(
@@ -464,21 +486,37 @@ export class NodeDriver {
       try {
         return await this.#executeEndpoint(state, executable, context);
       } catch (error) {
+        await context.recordExecution?.({ endpoint: executable.endpointId, kind: "failed", message: failureMessage(error) });
         throw new Error(
           `Endpoint ${executable.endpointId} failed ${executable.command.need.capability.name}: ${failureMessage(error)}`,
           { cause: error },
         );
       }
     }
+    let phase: string | undefined;
+    await context?.recordExecution?.({ endpoint: executable.endpointId, kind: "started" });
     try {
       const result = await executable.registration.handler({
         command: structuredClone(executable.command),
         need: structuredClone(executable.command.need),
         resources: this.#resourceStore(context?.build),
         credentials: await this.#endpointCredentials(executable.registration),
+        reportProgress: async (progress) => {
+          await context?.reportProgress?.({ endpoint: executable.endpointId, progress });
+          if (progress.phase !== phase) {
+            phase = progress.phase;
+            await context?.recordExecution?.({ endpoint: executable.endpointId, kind: "phase", phase });
+          }
+        },
+        ...(context?.recordExecution === undefined ? {} : {
+          reportDiagnostic: (diagnostic) => context.recordExecution!({ endpoint: executable.endpointId, kind: "diagnostic", ...diagnostic }),
+        }),
       });
-      return { status: "completed", event: await this.#endpointEvent(state, executable, result) };
+      const event = await this.#endpointEvent(state, executable, result);
+      await context?.recordExecution?.({ endpoint: executable.endpointId, kind: "completed" });
+      return { status: "completed", event };
     } catch (error) {
+      await context?.recordExecution?.({ endpoint: executable.endpointId, kind: "failed", message: failureMessage(error) });
       throw new Error(
         `Endpoint ${executable.endpointId} failed ${executable.command.need.capability.name}: ${failureMessage(error)}`,
         { cause: error },

package/packages/elevenlabs-speech/README.md

@@ -0,0 +1,27 @@
+# `@hypit/elevenlabs-speech`
+
+Exact model contract and author Surface for ElevenLabs Voice Design.
+
+`eleven_ttv_v3` creates an ordinary audio voice reference from a natural-language description of
+20 to 1000 characters and an authored speech sample of 100 to 1000 characters. The service returns
+several candidate previews; the Surface exposes the primary member of the shared `GeneratedAudioSet`
+as `<id>.reference`.
+
+It contains no API URL, credential, retry, queue or ElevenLabs wire encoding. Those belong to a
+Runtime Endpoint such as `@hypit/provider-hypihub`.
+
+```xml
+<import as="eleven" from="@hypit/elevenlabs-speech@1"/>
+
+<eleven:VoiceDesign id="host" speech={story.segment.voiceSample.speech}>
+  A clear young woman with a grounded, confident conversational delivery.
+</eleven:VoiceDesign>
+```
+
+`host.reference` is not a special identity record. It is a normal audio Resource, so the same
+accepted reference can be supplied anywhere an audio reference is accepted.
+
+Official API reference: <https://elevenlabs.io/docs/api-reference/text-to-voice/design>
+
+The Source import selects author syntax and exact model semantics only. The Runtime Profile
+independently selects the Provider that fulfils the capability.

package/packages/{provider-xiaomi-mimo → elevenlabs-speech}/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "@hypit/provider-xiaomi-mimo",
+  "name": "@hypit/elevenlabs-speech",
   "version": "0.0.0-dev",
   "license": "SEE LICENSE IN LICENSE",
   "private": true,
@@ -11,14 +11,11 @@
     "activation": "./src/activation.ts"
   },
   "dependencies": {
-    "@hypit/endpoint-kit": "workspace:*",
+    "@hypit/artifact": "workspace:*",
     "@hypit/generation": "workspace:*",
+    "@hypit/model-kit": "workspace:*",
     "@hypit/protocol": "workspace:*",
-    "@hypit/runtime": "workspace:*",
-    "@hypit/runtime-kit": "workspace:*"
-  },
-  "devDependencies": {
-    "@hypit/driver-node": "workspace:*",
-    "@hypit/mimo-speech": "workspace:*"
+    "@hypit/text": "workspace:*",
+    "@hypit/markup": "workspace:*"
   }
 }

package/packages/elevenlabs-speech/src/activation.ts

@@ -0,0 +1,26 @@
+import { createMarkupSurfaceHostFacet } from "@hypit/markup";
+
+import {
+  decodeElevenLabsVoiceDesignSurface,
+  elevenLabsSpeechComponent,
+  elevenLabsSpeechDefinition,
+  elevenLabsSpeechManifest,
+  elevenLabsSpeechMarkupSurfaces,
+  elevenLabsSpeechModuleRef,
+} from "./index.js";
+
+export const hypitPackage = {
+  format: "hypit.node-package@1" as const,
+  modules: [{ manifest: elevenLabsSpeechManifest }],
+  components: [elevenLabsSpeechComponent],
+  hostFacets: [
+    elevenLabsSpeechDefinition.hostFacet,
+    createMarkupSurfaceHostFacet({
+      module: elevenLabsSpeechModuleRef,
+      declaration: elevenLabsSpeechMarkupSurfaces.find((item) => item.name === "voiceDesign")!,
+      handler: decodeElevenLabsVoiceDesignSurface,
+    }),
+  ],
+};
+
+export default hypitPackage;

package/packages/elevenlabs-speech/src/fragment.ts

@@ -0,0 +1,11 @@
+import { createExactModelPrimaryGenerationFragment } from "@hypit/model-kit";
+import type { ExactModelEndpoint, ExactModelMediaInput, ExactModelTextInput } from "@hypit/model-kit";
+
+/** Model result projection over the same graph-native request assembly as every exact model. */
+export function createElevenLabsSpeechAudioFragment(
+  endpoint: ExactModelEndpoint,
+  mediaInputs: readonly ExactModelMediaInput[] = [],
+  textInputs: readonly ExactModelTextInput[] = [],
+) {
+  return createExactModelPrimaryGenerationFragment(endpoint, mediaInputs, textInputs);
+}