@hypit/hypit 0.0.1 → 0.1.0

package/packages/media-track/src/types.ts

@@ -0,0 +1,311 @@
+import type { FrameSpan, VisualTimedSampling } from "@hypit/composition";
+import type { CompositableSurfaceRef, MediaRational } from "@hypit/media";
+import type { BlobRef } from "@hypit/protocol";
+import type {
+  ContentFit,
+  IntrinsicExtent,
+  SpatialFrame,
+  SpatialPath,
+} from "@hypit/spatial";
+
+/** Intrinsic visual truth resolved before Media authoring; never a Provider or lineage envelope. */
+export type MediaVisualSource =
+  | {
+      readonly kind: "still";
+      readonly artifact: BlobRef;
+      readonly extent: IntrinsicExtent;
+    }
+  | {
+      readonly kind: "timed";
+      readonly artifact: BlobRef;
+      readonly extent: IntrinsicExtent;
+      readonly frameRate: MediaRational;
+      readonly frameCount: number;
+      readonly audio?: {
+        readonly artifact: BlobRef;
+        readonly sampleFrames: number;
+      };
+    }
+  | {
+      readonly kind: "surface";
+      readonly surface: CompositableSurfaceRef;
+      readonly extent: IntrinsicExtent;
+    };
+
+export type MediaVisualTrim = {
+  readonly startFrame: number;
+  readonly endFrameExclusive: number;
+};
+
+export type MediaVisualOccupancy =
+  | { readonly mode: "once"; readonly align: "start" | "end" }
+  | { readonly mode: "hold"; readonly align: "start" | "end" }
+  | { readonly mode: "loop"; readonly align: "start" | "end" }
+  | { readonly mode: "stretch" };
+
+export type MediaGradientStop = {
+  readonly offset: number;
+  readonly color: string;
+};
+
+export type MediaPaint =
+  | { readonly kind: "solid"; readonly color: string }
+  | {
+      readonly kind: "linear-gradient";
+      readonly angleDeg: number;
+      readonly stops: readonly MediaGradientStop[];
+    }
+  | {
+      readonly kind: "radial-gradient";
+      readonly center: { readonly x: number; readonly y: number };
+      readonly stops: readonly MediaGradientStop[];
+    };
+
+export type MediaSampleAppearance = {
+  readonly opacity: number;
+  readonly filter: {
+    readonly blurPx: number;
+    readonly brightness: number;
+    readonly contrast: number;
+    readonly saturation: number;
+  };
+};
+
+export type MediaSamplingKeyframe = {
+  /** Normalized position inside the resolved Item/member envelope. */
+  readonly atProgress: number;
+  readonly zoom: number;
+  readonly offsetX: number;
+  readonly offsetY: number;
+  readonly rotationDeg: number;
+  readonly easing?: "linear" | "ease-in" | "ease-out" | "ease-in-out";
+};
+
+export type MediaSamplingMotion = {
+  readonly keyframes: readonly MediaSamplingKeyframe[];
+};
+
+export type MediaPaintLayerProgram = {
+  readonly id: string;
+  readonly kind: "paint";
+  readonly paint: MediaPaint;
+  readonly opacity: number;
+};
+
+export type MediaSampleLayerProgram = {
+  readonly id: string;
+  readonly kind: "sample";
+  readonly sampling?: VisualTimedSampling;
+  readonly source: MediaVisualSource;
+  readonly fit: ContentFit;
+  readonly trim?: MediaVisualTrim;
+  readonly occupancy?: MediaVisualOccupancy;
+  readonly appearance: MediaSampleAppearance;
+  readonly samplingMotion?: MediaSamplingMotion;
+};
+
+export type MediaLayerProgram = MediaPaintLayerProgram | MediaSampleLayerProgram;
+
+export type MediaPaintLayerSpec = {
+  readonly id: string;
+  readonly paint: MediaPaint;
+  readonly opacity: number;
+};
+
+export type MediaSampleLayerSpec = {
+  readonly id: string;
+  readonly trim?: MediaVisualTrim;
+  readonly occupancy?: MediaVisualOccupancy;
+  readonly appearance: MediaSampleAppearance;
+  readonly samplingMotion?: MediaSamplingMotion;
+};
+
+export type MediaLayerSet = {
+  readonly layers: readonly MediaLayerProgram[];
+};
+
+export type MediaPadding = {
+  readonly topPx: number;
+  readonly rightPx: number;
+  readonly bottomPx: number;
+  readonly leftPx: number;
+};
+
+export type MediaFrameClip =
+  | { readonly kind: "none" }
+  | { readonly kind: "frame" }
+  | { readonly kind: "rounded"; readonly radiusPx: number }
+  | { readonly kind: "path"; readonly path: SpatialPath };
+
+export type MediaFramePresentation = {
+  readonly clip: MediaFrameClip;
+  readonly padding: MediaPadding;
+  readonly border?: {
+    readonly widthPx: number;
+    readonly style: "solid" | "dashed" | "dotted";
+    readonly color: string;
+  };
+  readonly shadows: readonly {
+    readonly offsetX: number;
+    readonly offsetY: number;
+    readonly blurPx: number;
+    readonly spreadPx: number;
+    readonly color: string;
+  }[];
+};
+
+export type MediaMotionDirection = "left" | "right" | "up" | "down";
+
+export type MediaEdgeMotion = {
+  readonly operator: "fade" | "slide" | "scale" | "pop" | "bounce" | "blur-reveal" | "wipe" | "flip" | "spin";
+  readonly durationFrames: number;
+  readonly easing: "linear" | "ease-in" | "ease-out" | "ease-in-out";
+  readonly direction?: MediaMotionDirection;
+  readonly amount?: number;
+  readonly origin?: "outside-canvas";
+};
+
+export type MediaSustainMotion = {
+  readonly operator: "float" | "breathe" | "pulse" | "wobble" | "shake" | "drift";
+  readonly amount: number;
+  readonly cycles: number;
+  readonly direction?: MediaMotionDirection;
+};
+
+export type MediaLifecycleMotion = {
+  readonly enter?: MediaEdgeMotion;
+  readonly sustain: readonly MediaSustainMotion[];
+  readonly exit?: MediaEdgeMotion;
+};
+
+export type MediaSourceAudioProjection = {
+  readonly fromLayer: string;
+  readonly gain: number;
+};
+
+export type MediaSoundSource = {
+  readonly artifact: BlobRef;
+  readonly sampleFrames: number;
+};
+
+export type MediaSoundTrigger =
+  | { readonly kind: "enter" }
+  | { readonly kind: "exit" }
+  | { readonly kind: "handoff"; readonly handoffId: string };
+
+export type MediaSoundSpec = {
+  readonly id: string;
+  readonly trigger: MediaSoundTrigger;
+  readonly gain: number;
+};
+
+export type MediaSoundEvent = MediaSoundSpec & {
+  readonly source: MediaSoundSource;
+};
+
+export type MediaSoundSet = {
+  readonly sounds: readonly MediaSoundEvent[];
+};
+
+export type MediaAbsoluteStacking = {
+  readonly order: number;
+  readonly tieBreak: string;
+};
+
+export type MediaItemSpec = {
+  readonly id: string;
+  readonly presentation: MediaFramePresentation;
+  readonly motion: MediaLifecycleMotion;
+  readonly stackingOrder: number;
+  readonly sourceAudio?: MediaSourceAudioProjection;
+};
+
+export type MediaItemProgram = {
+  readonly id: string;
+  /** Author-owned Item realized by this externally projected window. */
+  readonly subjectId: string;
+  readonly span: FrameSpan;
+  readonly frame: SpatialFrame;
+  readonly presentation: MediaFramePresentation;
+  readonly layers: readonly MediaLayerProgram[];
+  readonly motion: MediaLifecycleMotion;
+  readonly stacking: MediaAbsoluteStacking;
+  readonly sourceAudio?: MediaSourceAudioProjection;
+  readonly sounds: readonly MediaSoundEvent[];
+};
+
+export type MediaHandoffOperator = "cut" | "crossfade" | "push" | "wipe" | "cover" | "page-turn";
+
+export type MediaHandoffProgram = {
+  readonly id: string;
+  readonly fromMemberId: string;
+  readonly toMemberId: string;
+  readonly operator: MediaHandoffOperator;
+  readonly durationFrames: number;
+  readonly boundaryRatio: number;
+  readonly span: FrameSpan;
+  readonly direction?: MediaMotionDirection;
+  readonly audio: "cut" | "crossfade";
+};
+
+export type MediaSequenceMemberProgram = {
+  readonly id: string;
+  readonly activationFrame: number;
+  readonly logicalSpan: FrameSpan;
+  readonly visualSpan: FrameSpan;
+  readonly layers: readonly MediaLayerProgram[];
+  readonly sourceAudio?: MediaSourceAudioProjection;
+};
+
+export type MediaSequenceMemberSpec = {
+  readonly id: string;
+  readonly sourceAudio?: MediaSourceAudioProjection;
+};
+
+export type MediaSequenceMemberSet = {
+  readonly members: readonly {
+    readonly id: string;
+    readonly activationFrame: number;
+    readonly layers: readonly MediaLayerProgram[];
+    readonly sourceAudio?: MediaSourceAudioProjection;
+  }[];
+};
+
+export type MediaHandoffSpec = Omit<MediaHandoffProgram, "span"> & {
+};
+
+export type MediaSequenceSpec = {
+  readonly id: string;
+  readonly presentation: MediaFramePresentation;
+  readonly motion: MediaLifecycleMotion;
+  readonly stackingOrder: number;
+  readonly handoffs: readonly MediaHandoffSpec[];
+};
+
+export type MediaSequenceProgram = {
+  readonly id: string;
+  readonly span: FrameSpan;
+  readonly terminalFrame: number;
+  readonly frame: SpatialFrame;
+  readonly presentation: MediaFramePresentation;
+  readonly members: readonly MediaSequenceMemberProgram[];
+  readonly handoffs: readonly MediaHandoffProgram[];
+  readonly motion: MediaLifecycleMotion;
+  readonly stacking: MediaAbsoluteStacking;
+  readonly sounds: readonly MediaSoundEvent[];
+};
+
+export type MediaTrackProgram = {
+  readonly id: string;
+  readonly items: readonly MediaItemProgram[];
+  readonly sequences: readonly MediaSequenceProgram[];
+};
+
+export type MediaTrackHeader = {
+  readonly id: string;
+};
+
+export type MediaTrackSet = {
+  readonly items: readonly MediaItemProgram[];
+  readonly sequences: readonly MediaSequenceProgram[];
+};

package/packages/media-track-studio/README.md

@@ -0,0 +1,3 @@
+# `@hypit/media-track-studio`
+
+Hypit Studio Companion for `@hypit/media-track`.

package/packages/media-track-studio/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@hypit/media-track-studio",
+  "version": "0.0.0-dev",
+  "license": "SEE LICENSE IN LICENSE",
+  "private": true,
+  "type": "module",
+  "exports": { ".": "./src/index.ts" },
+  "hypit": { "activation": "./src/activation.ts" },
+  "dependencies": {
+    "@hypit/media-track": "workspace:*",
+    "@hypit/composition": "workspace:*",
+    "@hypit/protocol": "workspace:*",
+    "@hypit/studio-adapter": "workspace:*"
+  }
+}

package/packages/media-track-studio/src/activation.ts

@@ -0,0 +1,7 @@
+import { createStudioTrackCompanionHostFacet } from "@hypit/studio-adapter";
+import { mediaTrackStudioTrackCompanions } from "./index.js";
+
+export default {
+  format: "hypit.node-package@1" as const,
+  hostFacets: [createStudioTrackCompanionHostFacet(mediaTrackStudioTrackCompanions)],
+};

package/packages/media-track-studio/src/index.ts

@@ -0,0 +1,235 @@
+import { mediaTrackMarkupSurfaces, mediaTrackModuleRef, mediaTrackTypes } from "@hypit/media-track";
+import type { MediaLayerProgram, MediaTrackProgram } from "@hypit/media-track";
+import { compositionTypes } from "@hypit/composition";
+import { sameType } from "@hypit/protocol";
+import type {
+  StudioTrackCompanion,
+  StudioTrackCompanionContext,
+  StudioEntityDraft,
+  StudioInspectorFieldDeclaration,
+  StudioMaterialPreview,
+  StudioSourceBindingDeclaration,
+} from "@hypit/studio-adapter";
+import { artifactPreview, childEntities, previewLayer, requiredSurfaceValue, temporalLineageFor, temporalSemanticSource } from "@hypit/studio-adapter";
+
+const frameParameters: readonly StudioSourceBindingDeclaration[] = [
+  { name: "within" },
+  { name: "left", writable: true },
+  { name: "top", writable: true },
+  { name: "right", writable: true },
+  { name: "bottom", writable: true },
+  { name: "x", writable: true },
+  { name: "y", writable: true },
+  { name: "width", writable: true },
+  { name: "height", writable: true },
+];
+
+const extentParameters: readonly StudioSourceBindingDeclaration[] = [
+  { name: "width", writable: true },
+  { name: "height", writable: true },
+];
+
+const mediaTrackSurface = mediaTrackMarkupSurfaces.find((surface) => surface.name === "track");
+const mediaItemAttributes = mediaTrackSurface?.vocabulary.children?.find((child) => child.tag === "Item")?.attributes ?? [];
+
+function title(name: string): string {
+  return name.split("-").map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`).join(" ");
+}
+
+function valuesFor(property: { readonly name: string }): readonly string[] | undefined {
+  return "values" in property ? (property as { readonly values: readonly string[] }).values : undefined;
+}
+
+type MediaPlacement = Pick<StudioInspectorFieldDeclaration, "domain" | "page" | "section">;
+
+function mediaPlace(domain: "where" | "how" | "when", page: string, section: string): MediaPlacement {
+  const id = section.toLowerCase().replaceAll(" ", "-");
+  return { domain, page: { id: page.toLowerCase(), label: page }, section: { id, label: section } };
+}
+
+const mediaPlacement = new Map<string, MediaPlacement>();
+function placeMedia(names: readonly string[], domain: "where" | "how" | "when", page: string, section: string): void {
+  for (const name of names) mediaPlacement.set(name, mediaPlace(domain, page, section));
+}
+
+placeMedia([
+  "fit", "frame-x", "frame-y", "content-x", "content-y", "fit-offset-x", "fit-offset-y", "fit-constraint",
+], "where", "Fit", "Fit");
+placeMedia(["stack-order"], "where", "Frame", "Stacking");
+placeMedia(["clip", "radius", "padding"], "where", "Frame", "Geometry");
+placeMedia(["opacity", "blur", "brightness", "contrast", "saturation"], "how", "Image", "Image");
+placeMedia(["playback", "trim-start", "trim-end"], "how", "Playback", "Playback");
+placeMedia(["border-width", "border-style", "border-color", "shadows", "frame-paint"], "how", "Frame", "Paint");
+placeMedia(["enter", "enter-frames", "enter-easing", "enter-direction", "enter-amount", "enter-origin"], "when", "Enter", "Enter");
+placeMedia(["sustain"], "when", "Sustain", "Sustain");
+placeMedia(["exit", "exit-frames", "exit-easing", "exit-direction", "exit-amount", "exit-origin"], "when", "Exit", "Exit");
+
+const mediaColorProperties = new Set(["border-color"]);
+const mediaTextProperties = new Set(["padding", "shadows", "frame-paint", "sustain"]);
+
+function mediaRecipe(name: "appearance" | "motion"): {
+  readonly bindings: readonly { readonly name: string }[];
+  readonly inspector: readonly StudioInspectorFieldDeclaration[];
+} {
+  const attribute = mediaItemAttributes.find((candidate) => candidate.name === name);
+  const properties = attribute !== undefined && "recipe" in attribute ? attribute.recipe : [];
+  return {
+    bindings: properties.map(({ name: property }) => ({ name: property })),
+    inspector: properties.map((property) => {
+      const placement = mediaPlacement.get(property.name);
+      if (placement === undefined) throw new Error(`Media Studio has no explicit Inspector declaration for ${property.name}.`);
+      const options = valuesFor(property);
+      const control = options !== undefined ? "select" as const
+        : mediaColorProperties.has(property.name) ? "color" as const
+        : mediaTextProperties.has(property.name) ? "text" as const : "number" as const;
+      return {
+        binding: `${name}.${property.name}`,
+        label: title(property.name),
+        ...placement,
+        ...(property.summary === undefined ? {} : { summary: property.summary }),
+        control,
+        ...(options === undefined ? {} : { options }),
+      };
+    }),
+  };
+}
+
+const mediaAppearanceRecipe = mediaRecipe("appearance");
+const mediaMotionRecipe = mediaRecipe("motion");
+
+function materialPreview(
+  layers: readonly MediaLayerProgram[],
+  facet: "visual" | "audio",
+  audioFromLayer?: string,
+): StudioMaterialPreview | undefined {
+  const layer = layers.find((candidate) => candidate.kind === "sample"
+    && (facet === "visual" || audioFromLayer === undefined || candidate.id === audioFromLayer));
+  if (layer?.kind !== "sample") return undefined;
+  if (facet === "audio") {
+    const artifact = layer.source.kind === "timed" ? layer.source.audio?.artifact : undefined;
+    return artifact === undefined ? undefined : artifactPreview("audio", artifact.resource);
+  }
+  if (layer.source.kind === "surface") return undefined;
+  return artifactPreview(layer.source.kind === "still" ? "image" : "video", layer.source.artifact.resource);
+}
+
+function projectMedia(context: StudioTrackCompanionContext): readonly StudioEntityDraft[] {
+  const program = requiredSurfaceValue(context, "program") as MediaTrackProgram;
+  const facet = sameType(context.track.typeRef, compositionTypes.audioTrack) ? "audio" : "visual";
+  const items = [
+    ...program.items.map((item) => ({
+      id: item.id,
+      subjectId: item.subjectId,
+      startFrame: item.span.startFrame,
+      endFrameExclusive: item.span.endFrameExclusive,
+      stackOrder: item.stacking.order,
+      preview: materialPreview(item.layers, facet, item.sourceAudio?.fromLayer),
+      temporalInput: "window",
+      sourceTypes: [mediaTrackTypes.itemSpec],
+    })),
+    ...program.sequences.map((sequence) => ({
+      id: sequence.id,
+      subjectId: sequence.id,
+      startFrame: sequence.span.startFrame,
+      endFrameExclusive: sequence.span.endFrameExclusive,
+      stackOrder: sequence.stacking.order,
+      preview: sequence.members[0] === undefined
+        ? undefined
+        : materialPreview(sequence.members[0].layers, facet, sequence.members[0].sourceAudio?.fromLayer),
+      temporalInput: "terminal",
+      sourceTypes: [mediaTrackTypes.sequenceSpec],
+    })),
+  ];
+  return childEntities(context, items, "media-item", "standard")
+    .map((entity, index) => {
+      const item = items[index];
+      if (item === undefined) return entity;
+      const temporal = temporalLineageFor(context, item.id, item.temporalInput);
+      const semanticSource = temporalSemanticSource(temporal);
+      return {
+        ...entity,
+        ...(semanticSource?.id === undefined
+          ? {}
+          : { markerId: semanticSource.id }),
+        ...(item.preview === undefined ? {} : {
+          display: {
+            ...entity.display,
+            layers: [previewLayer(item.preview, facet === "audio" ? "waveform" : item.preview.kind === "video" ? "storyboard" : "repeat-x")],
+          },
+        }),
+        ...(temporal === undefined ? {} : { temporal }),
+      };
+    });
+}
+
+const commonBindings: readonly StudioSourceBindingDeclaration[] = [
+  { name: "source-audio", writable: true },
+  { name: "audio-gain", writable: true },
+  { name: "until" },
+  { name: "until-boundary", writable: true },
+];
+
+const commonInspector: readonly StudioInspectorFieldDeclaration[] = [
+  {
+    binding: "audio-gain", label: "Audio Gain", domain: "how",
+    page: { id: "audio", label: "Audio" }, section: { id: "audio", label: "Audio" }, control: "number",
+  },
+  {
+    binding: "until-boundary", label: "Until Boundary", domain: "when",
+    page: { id: "boundary", label: "Boundary" }, section: { id: "boundary", label: "Boundary" },
+    control: "select", options: ["start", "end"],
+  },
+];
+
+const frameSizeParameters = new Set(["width", "height"]);
+
+export const mediaTrackStudioTrackCompanions: readonly StudioTrackCompanion[] = [
+  {
+    id: "visual", role: "track",
+    output: { type: compositionTypes.visualTrack, surface: "track", modules: [mediaTrackModuleRef] },
+    family: "media", tone: "blue", icon: "video",
+    bindings: [
+      ...commonBindings,
+      { name: "extent", referenced: extentParameters },
+      { name: "clip" },
+      { name: "image" },
+      { name: "media" },
+      { name: "surface" },
+      { name: "frame", referenced: frameParameters },
+      {
+        name: "appearance",
+        recipe: { bindings: mediaAppearanceRecipe.bindings },
+      },
+      {
+        name: "motion",
+        recipe: { bindings: mediaMotionRecipe.bindings },
+      },
+    ],
+    inspector: [
+      ...frameParameters.filter(({ writable }) => writable === true).map(({ name }) => ({
+        binding: `frame.${name}`, label: title(name), domain: "where" as const,
+        page: { id: frameSizeParameters.has(name) ? "size" : "placement", label: frameSizeParameters.has(name) ? "Size" : "Placement" },
+        section: { id: "frame", label: "Frame" }, control: "text" as const,
+      })),
+      ...extentParameters.map(({ name }) => ({
+        binding: `extent.${name}`, label: title(name), domain: "where" as const,
+        page: { id: "size", label: "Size" }, section: { id: "extent", label: "Source Extent" },
+        control: "number" as const, unit: "px",
+      })),
+      ...mediaAppearanceRecipe.inspector,
+      ...mediaMotionRecipe.inspector,
+      ...commonInspector,
+    ],
+    requiredValues: ["program"], project: projectMedia,
+    lane: { heightPx: 76 },
+  },
+  {
+    id: "audio", role: "track",
+    output: { type: compositionTypes.audioTrack, surface: "track", modules: [mediaTrackModuleRef] },
+    family: "media-audio", tone: "green", icon: "waveform",
+    bindings: commonBindings,
+    inspector: commonInspector,
+    requiredValues: ["program"], project: projectMedia,
+    lane: { heightPx: 48 },
+  },
+];

package/packages/mimo-speech/README.md

@@ -0,0 +1,33 @@
+# `@hypit/mimo-speech`
+
+Exact model contracts and author Surfaces for Xiaomi MiMo V2.5 Voice Design and Voice Clone.
+
+The package owns two distinct speech operations:
+
+- `mimo-v2.5-tts-voicedesign` creates an ordinary audio voice reference from a natural-language
+  description and a short authored speech sample;
+- `mimo-v2.5-tts-voiceclone` uses one accepted audio voice reference to create independent speech.
+
+It contains no API URL, credential, retry, queue or Xiaomi wire encoding. Those belong to a Runtime
+Endpoint such as `@hypit/provider-xiaomi-mimo`. Both models return the shared `GeneratedAudioSet`;
+the author Surfaces expose its primary member as an ordinary audio Resource.
+
+```xml
+<import as="mimo" from="@hypit/mimo-speech@1"/>
+
+<mimo:VoiceDesign id="host" speech={story.segment.voiceSample.speech}>
+  A clear young woman with a grounded, confident conversational delivery.
+</mimo:VoiceDesign>
+
+<mimo:VoiceClone id="narration" speech={story.segment.reveal.speech} voice={host.reference}>
+  Quietly confident, with a short pause before the final word.
+</mimo:VoiceClone>
+```
+
+`host.reference` is not a special identity record. It is a normal audio Resource, so the same
+accepted reference can also feed an A-roll video model that accepts reference audio.
+
+Official API reference: <https://mimo.mi.com/docs/zh-CN/quick-start/usage-guide/audio/speech-synthesis-v2.5>
+
+The Source import selects author syntax and exact model semantics only. The Runtime Profile
+independently selects the Provider that fulfils either capability.

package/packages/mimo-speech/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@hypit/mimo-speech",
+  "version": "0.0.0-dev",
+  "license": "SEE LICENSE IN LICENSE",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "hypit": {
+    "activation": "./src/activation.ts"
+  },
+  "dependencies": {
+    "@hypit/artifact": "workspace:*",
+    "@hypit/generation": "workspace:*",
+    "@hypit/model-kit": "workspace:*",
+    "@hypit/protocol": "workspace:*",
+    "@hypit/text": "workspace:*",
+    "@hypit/markup": "workspace:*"
+  }
+}

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

@@ -0,0 +1,32 @@
+import { createMarkupSurfaceHostFacet } from "@hypit/markup";
+
+import {
+  decodeMimoVoiceCloneSurface,
+  decodeMimoVoiceDesignSurface,
+  mimoSpeechComponent,
+  mimoSpeechDefinition,
+  mimoSpeechManifest,
+  mimoSpeechMarkupSurfaces,
+  mimoSpeechModuleRef,
+} from "./index.js";
+
+export const hypitPackage = {
+  format: "hypit.node-package@1" as const,
+  modules: [{ manifest: mimoSpeechManifest }],
+  components: [mimoSpeechComponent],
+  hostFacets: [
+    mimoSpeechDefinition.hostFacet,
+    createMarkupSurfaceHostFacet({
+      module: mimoSpeechModuleRef,
+      declaration: mimoSpeechMarkupSurfaces.find((item) => item.name === "voiceDesign")!,
+      handler: decodeMimoVoiceDesignSurface,
+    }),
+    createMarkupSurfaceHostFacet({
+      module: mimoSpeechModuleRef,
+      declaration: mimoSpeechMarkupSurfaces.find((item) => item.name === "voiceClone")!,
+      handler: decodeMimoVoiceCloneSurface,
+    }),
+  ],
+};
+
+export default hypitPackage;

package/packages/mimo-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 createMimoSpeechAudioFragment(
+  endpoint: ExactModelEndpoint,
+  mediaInputs: readonly ExactModelMediaInput[] = [],
+  textInputs: readonly ExactModelTextInput[] = [],
+) {
+  return createExactModelPrimaryGenerationFragment(endpoint, mediaInputs, textInputs);
+}