@hypit/hypit 0.1.4 → 0.1.5

package/packages/provider-kie/src/routes.ts

@@ -1,150 +0,0 @@
-import { artifactTypes } from "@hypit/artifact";
-import {
-  assertBackgroundRemovalRequest,
-  backgroundRemovalCapabilities,
-} from "@hypit/background-removal";
-import type { BackgroundRemovalRequest } from "@hypit/background-removal";
-import {
-  compileWireRequest,
-  generationTypes,
-  selectWireModelForRequest,
-  sealGeneratedImageSet,
-  sealGeneratedVideoSet,
-} from "@hypit/generation";
-import type { GenerationArtifactUrlResolver, GenerationRequest, GenerationWireMapping } from "@hypit/generation";
-import { canonicalize } from "@hypit/protocol";
-import type { BlobRef, CanonicalValue, CapabilityRef, StoredValue, TypeRef } from "@hypit/protocol";
-import type { EndpointRequest, EndpointSupport } from "@hypit/endpoint-kit";
-
-import { kieModelCatalog, verifyKieModelCatalog } from "./mapping.js";
-
-export type KieTaskRequest = {
-  readonly model: string;
-  readonly input: CanonicalValue;
-};
-
-export type KieRoute = {
-  readonly key: string;
-  readonly capability: CapabilityRef;
-  readonly returns: TypeRef;
-  readonly media: "image" | "video";
-  readonly maxResults: number;
-  readonly supports?: (request: EndpointRequest) => EndpointSupport;
-  /** Select the same service model before or during execution, without resolving Resource bytes. */
-  readonly selectModel: (request: EndpointRequest) => string;
-  readonly compile: (
-    constraints: CanonicalValue,
-    resolve: GenerationArtifactUrlResolver,
-  ) => Promise<KieTaskRequest>;
-  readonly packageResult: (artifacts: readonly BlobRef[]) => StoredValue;
-};
-
-function capabilityKey(ref: CapabilityRef): string {
-  return `${ref.module.name}@${ref.module.version}#${ref.name}`;
-}
-
-function scalar(request: GenerationRequest, port: string): string | number | boolean | undefined {
-  const value = request.ports[port]?.[0];
-  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? value : undefined;
-}
-
-/** Returns the KIE-wire limitation that rejects an otherwise valid model request. */
-function kieGenerationRejection(mapping: GenerationWireMapping, request: GenerationRequest): string | undefined {
-  if (mapping.capability.module.name === "@hypit/gpt-image" && mapping.capability.name === "gpt-image-2") {
-    const ratio = scalar(request, "aspectRatio");
-    const resolution = scalar(request, "resolution");
-    const background = scalar(request, "background");
-    const unsupportedRatios = resolution === "2K"
-      ? ["5:4", "4:5", "3:1", "1:3", "9:21"]
-      : resolution === "4K" ? ["3:1", "1:3", "9:21"] : [];
-    if (unsupportedRatios.includes(String(ratio))) {
-      return `KIE GPT Image 2 does not accept ${String(ratio)} at ${String(resolution)}`;
-    }
-    if (background !== undefined && resolution !== "1K") {
-      return `KIE GPT Image 2 accepts the background option only at 1K; omit it at ${String(resolution)}`;
-    }
-  }
-  if (mapping.capability.module.name === "@hypit/grok-imagine"
-    && (mapping.capability.name === "grok-imagine-video"
-      || mapping.capability.name === "grok-imagine-video-1.5-preview")
-    && scalar(request, "resolution") === "1080p"
-    && (request.ports.images?.length ?? 0) > 1) {
-    return `KIE ${mapping.capability.name} accepts at most one reference image at 1080p`;
-  }
-  return undefined;
-}
-
-const kieGenerationMappings: readonly (GenerationWireMapping & { readonly result: "image" | "video" })[] = kieModelCatalog.map((mapping) => {
-  if (mapping.result === "audio") {
-    throw new Error(`KIE route ${mapping.capability.name} declares unsupported audio output`);
-  }
-  return mapping as GenerationWireMapping & { readonly result: "image" | "video" };
-});
-
-const generationRoutes: readonly KieRoute[] = kieGenerationMappings.map((mapping) => ({
-  key: capabilityKey(mapping.capability),
-  capability: mapping.capability,
-  returns: mapping.result === "image" ? generationTypes.imageSet : generationTypes.videoSet,
-  media: mapping.result,
-  maxResults: mapping.result === "image" ? 16 : 8,
-  supports: (need: EndpointRequest) => {
-    const reason = kieGenerationRejection(mapping, need.constraints as unknown as GenerationRequest);
-    return reason === undefined ? { status: "supported" } : { status: "unsupported", reason };
-  },
-  selectModel: (need) => selectWireModelForRequest(
-    mapping,
-    need.constraints as unknown as GenerationRequest,
-    need.pendingInputs?.map((input) => input.input),
-  ),
-  compile: async (constraints, resolve) => {
-    const request = constraints as unknown as GenerationRequest;
-    const rejection = kieGenerationRejection(mapping, request);
-    if (rejection !== undefined) throw new Error(rejection);
-    return await compileWireRequest(mapping, request, resolve);
-  },
-  packageResult: (artifacts) => ({
-    kind: "inline",
-    value: canonicalize(mapping.result === "image"
-      ? sealGeneratedImageSet({ images: artifacts })
-      : sealGeneratedVideoSet({ videos: artifacts })),
-  }),
-}));
-
-const backgroundRemovalRoute: KieRoute = {
-  key: capabilityKey(backgroundRemovalCapabilities.remove),
-  capability: backgroundRemovalCapabilities.remove,
-  returns: artifactTypes.blob,
-  media: "image",
-  maxResults: 1,
-  selectModel: () => "recraft/remove-background",
-  compile: async (constraints, resolve) => {
-    const request = constraints as unknown as BackgroundRemovalRequest;
-    assertBackgroundRemovalRequest(request);
-    return {
-      model: "recraft/remove-background",
-      input: canonicalize({ image: await resolve(request.source) }),
-    };
-  },
-  packageResult: (artifacts) => {
-    if (artifacts.length !== 1 || artifacts[0] === undefined) {
-      throw new Error("KIE Background Removal requires exactly one image result");
-    }
-    return artifacts[0];
-  },
-};
-
-export const kieRoutes: readonly KieRoute[] = [...generationRoutes, backgroundRemovalRoute];
-const routeByCapability = new Map(kieRoutes.map((route) => [route.key, route]));
-
-export function kieRouteForCapability(capability: CapabilityRef): KieRoute | undefined {
-  return routeByCapability.get(capabilityKey(capability));
-}
-
-export function verifyKieRoutes(): void {
-  verifyKieModelCatalog();
-  if (routeByCapability.size !== kieRoutes.length) throw new Error("KIE routes repeat a capability");
-  kieRoutes.forEach((route) => {
-    if (route.key !== capabilityKey(route.capability)) throw new Error("KIE route key differs from its capability");
-    if (!Number.isSafeInteger(route.maxResults) || route.maxResults <= 0) throw new Error("KIE route result limit is invalid");
-  });
-}

package/packages/provider-xiaomi-mimo/README.md

@@ -1,32 +0,0 @@
-# `@hypit/provider-xiaomi-mimo`
-
-Immediate Runtime Endpoint for Xiaomi's official MiMo V2.5 Voice Design and Voice Clone APIs.
-
-This package owns the `chat/completions` wire shape, `api-key` credential, timeout, response bounds,
-voice-reference encoding and ResourceStore ingestion. It names `@hypit/mimo-speech@1` capabilities
-as versioned data and does not import the model package at runtime.
-
-Runtime Profile example:
-
-```json
-{
-  "endpoints": {
-    "mimo.official": {
-      "use": "@hypit/provider-xiaomi-mimo",
-      "pool": "mimo.official",
-      "config": {
-        "apiKey": { "store": "os", "key": "xiaomi-mimo.api-key" },
-        "defaultConcurrency": 2
-      }
-    }
-  }
-}
-```
-
-Voice Design sends the authored voice description. Voice Clone reads the selected audio Resource,
-checks Xiaomi's accepted MP3/WAV formats and sends it as the vendor's data-URL voice reference.
-The Provider always requests final WAV bytes.
-
-Selecting this Provider in the Runtime Profile is independent from author syntax. Its pool and
-capability claims participate in the shared Runtime capacity model; the package has no private
-scheduler.

package/packages/provider-xiaomi-mimo/src/activation.ts

@@ -1,57 +0,0 @@
-import {
-  createRuntimeEndpointAdapterFacet,
-  runtimeConfigCredentialRef,
-  runtimeConfigExact,
-  runtimeConfigObject,
-  runtimeConfigPositiveInteger,
-  runtimeConfigString,
-} from "@hypit/runtime-kit";
-
-import { createXiaomiMimoProvider } from "./provider.js";
-
-const adapter = createRuntimeEndpointAdapterFacet({
-  use: "@hypit/provider-xiaomi-mimo",
-  activate(context) {
-    if (context.pool === undefined) throw new Error("Xiaomi MiMo Provider Pool is required");
-    const config = runtimeConfigObject(context.config, "Xiaomi MiMo");
-    runtimeConfigExact(config, [
-      "apiBaseUrl", "apiKey", "defaultConcurrency", "requestTimeoutMs",
-      "maxResponseBytes", "maxVoiceReferenceBase64Bytes",
-    ], "Xiaomi MiMo");
-    const apiBaseUrl = runtimeConfigString(config.apiBaseUrl, "Xiaomi MiMo apiBaseUrl");
-    if (apiBaseUrl !== undefined) {
-      const url = new URL(apiBaseUrl);
-      if (url.protocol !== "https:" && url.hostname !== "localhost" && url.hostname !== "127.0.0.1") {
-        throw new Error("Xiaomi MiMo apiBaseUrl must use HTTPS or loopback");
-      }
-    }
-    const apiKey = runtimeConfigCredentialRef(config.apiKey, "Xiaomi MiMo apiKey");
-    if (apiKey === undefined) throw new Error("Xiaomi MiMo apiKey CredentialRef is required");
-    const defaultConcurrency = runtimeConfigPositiveInteger(config.defaultConcurrency, "Xiaomi MiMo defaultConcurrency");
-    const requestTimeoutMs = runtimeConfigPositiveInteger(config.requestTimeoutMs, "Xiaomi MiMo requestTimeoutMs");
-    const maxResponseBytes = runtimeConfigPositiveInteger(config.maxResponseBytes, "Xiaomi MiMo maxResponseBytes");
-    const maxVoiceReferenceBase64Bytes = runtimeConfigPositiveInteger(
-      config.maxVoiceReferenceBase64Bytes,
-      "Xiaomi MiMo maxVoiceReferenceBase64Bytes",
-    );
-    return {
-      endpoint: createXiaomiMimoProvider({
-        instance: context.instance,
-        pool: context.pool,
-        ...(apiBaseUrl === undefined ? {} : { apiBaseUrl }),
-        apiKey,
-        ...(defaultConcurrency === undefined ? {} : { defaultConcurrency }),
-        ...(requestTimeoutMs === undefined ? {} : { requestTimeoutMs }),
-        ...(maxResponseBytes === undefined ? {} : { maxResponseBytes }),
-        ...(maxVoiceReferenceBase64Bytes === undefined ? {} : { maxVoiceReferenceBase64Bytes }),
-      }),
-    };
-  },
-});
-
-export const hypitPackage = {
-  format: "hypit.node-package@1" as const,
-  hostFacets: [adapter],
-};
-
-export default hypitPackage;

package/packages/provider-xiaomi-mimo/src/index.ts

@@ -1,5 +0,0 @@
-export {
-  createXiaomiMimoProvider,
-  xiaomiMimoProviderModuleRef,
-} from "./provider.js";
-export type { CreateXiaomiMimoProviderOptions } from "./provider.js";

package/packages/provider-xiaomi-mimo/src/provider.ts

@@ -1,214 +0,0 @@
-import { defineEndpointPackage } from "@hypit/endpoint-kit";
-import type { EndpointInvocationContext } from "@hypit/endpoint-kit";
-import {
-  generationTypes,
-  sealGeneratedAudioSet,
-} from "@hypit/generation";
-import type { GenerationMediaValue, GenerationRequest } from "@hypit/generation";
-import type { CanonicalValue, CapabilityRef } from "@hypit/protocol";
-import { credentialRef } from "@hypit/runtime";
-import type { CredentialRef } from "@hypit/runtime";
-
-export const xiaomiMimoProviderModuleRef = { name: "@hypit/provider-xiaomi-mimo", version: "1" } as const;
-const mimoModelModule = { name: "@hypit/mimo-speech", version: "1" } as const;
-const modelNames = ["mimo-v2.5-tts-voicedesign", "mimo-v2.5-tts-voiceclone"] as const;
-type Model = typeof modelNames[number];
-
-const capabilities = Object.fromEntries(modelNames.map((name) => [name, {
-  module: mimoModelModule,
-  name,
-}])) as Readonly<Record<Model, CapabilityRef>>;
-
-type Fetch = typeof globalThis.fetch;
-
-export type CreateXiaomiMimoProviderOptions = {
-  readonly instance?: string;
-  readonly pool?: string;
-  readonly apiBaseUrl?: string;
-  readonly apiKey?: CredentialRef;
-  readonly defaultConcurrency?: number;
-  readonly requestTimeoutMs?: number;
-  readonly maxResponseBytes?: number;
-  readonly maxVoiceReferenceBase64Bytes?: number;
-  readonly fetch?: Fetch;
-};
-
-function assert(condition: unknown, message: string): asserts condition {
-  if (!condition) throw new Error(message);
-}
-
-function positiveInteger(value: number, subject: string): number {
-  assert(Number.isSafeInteger(value) && value > 0, `${subject} must be a positive integer`);
-  return value;
-}
-
-function normalizeBaseUrl(value: string): string {
-  const url = new URL(value);
-  assert(url.protocol === "https:" || url.hostname === "localhost" || url.hostname === "127.0.0.1",
-    "Xiaomi MiMo apiBaseUrl must use HTTPS or loopback");
-  return url.href.replace(/\/$/u, "");
-}
-
-function request(value: CanonicalValue, model: Model): GenerationRequest {
-  const result = value as unknown as GenerationRequest;
-  assert(result.ports !== null && typeof result.ports === "object", "Xiaomi MiMo request has no ports");
-  const allowed = model === "mimo-v2.5-tts-voicedesign"
-    ? new Set(["text", "voiceDescription"])
-    : new Set(["text", "instruction", "voiceReference"]);
-  assert(Object.keys(result.ports).every((name) => allowed.has(name)),
-    `${model} request contains an unsupported port`);
-  return result;
-}
-
-function scalar(req: GenerationRequest, model: Model, name: string, required = true): string | undefined {
-  const values = req.ports[name];
-  if (values === undefined) {
-    if (required) throw new Error(`${model} requires ${name}`);
-    return undefined;
-  }
-  assert(values.length === 1 && typeof values[0] === "string", `${model} ${name} must contain one string`);
-  return values[0];
-}
-
-function credential(context: EndpointInvocationContext): string {
-  const value = context.credentials.apiKey?.secret;
-  assert(value !== undefined && value.length > 0, "Xiaomi MiMo API key is unavailable");
-  return value;
-}
-
-async function readVoiceReference(
-  context: EndpointInvocationContext,
-  req: GenerationRequest,
-  maxBase64Bytes: number,
-): Promise<string> {
-  const values = req.ports.voiceReference;
-  assert(values?.length === 1, "MiMo Voice Clone requires exactly one voiceReference");
-  const value = values[0] as GenerationMediaValue;
-  assert(value.role === "audio", "MiMo Voice Clone voiceReference must be audio");
-  const supported = new Set(["audio/mpeg", "audio/mp3", "audio/wav", "audio/x-wav"]);
-  assert(supported.has(value.artifact.mediaType), "Xiaomi MiMo accepts only MP3 or WAV voice references");
-  const encodedSize = 4 * Math.ceil(value.artifact.size / 3);
-  assert(encodedSize <= maxBase64Bytes,
-    `MiMo voice reference exceeds the configured ${maxBase64Bytes}-byte Base64 limit`);
-  const bytes = await context.resources.get(value.artifact.resource);
-  assert(bytes !== undefined, `MiMo voice reference ${value.artifact.resource} is unavailable`);
-  assert(bytes.byteLength === value.artifact.size, "MiMo voice reference size differs from its BlobRef");
-  const mediaType = value.artifact.mediaType === "audio/x-wav"
-    ? "audio/wav"
-    : value.artifact.mediaType === "audio/mp3" ? "audio/mpeg" : value.artifact.mediaType;
-  const encoded = Buffer.from(bytes).toString("base64");
-  assert(Buffer.byteLength(encoded, "utf8") <= maxBase64Bytes,
-    `MiMo voice reference exceeds the configured ${maxBase64Bytes}-byte Base64 limit`);
-  return `data:${mediaType};base64,${encoded}`;
-}
-
-function parseAudio(text: string, maxAudioBytes: number): Uint8Array {
-  let raw: unknown;
-  try {
-    raw = JSON.parse(text);
-  } catch {
-    throw new Error("Xiaomi MiMo returned invalid JSON");
-  }
-  const root = raw as { choices?: Array<{ message?: { audio?: { data?: unknown } } }> };
-  const data = root.choices?.[0]?.message?.audio?.data;
-  assert(typeof data === "string" && data.length > 0, "Xiaomi MiMo returned no audio data");
-  assert(data.length % 4 === 0 && /^[A-Za-z0-9+/]*={0,2}$/u.test(data),
-    "Xiaomi MiMo returned malformed Base64 audio");
-  const bytes = Uint8Array.from(Buffer.from(data, "base64"));
-  assert(bytes.byteLength > 0, "Xiaomi MiMo returned empty audio");
-  assert(bytes.byteLength <= maxAudioBytes, "Xiaomi MiMo audio exceeds the configured limit");
-  return bytes;
-}
-
-async function limitedResponseText(response: Response, maxBytes: number): Promise<string> {
-  const announced = response.headers.get("content-length");
-  if (announced !== null) {
-    const size = Number(announced);
-    assert(Number.isSafeInteger(size) && size >= 0, "Xiaomi MiMo returned invalid Content-Length");
-    assert(size <= maxBytes, "Xiaomi MiMo response exceeds the configured limit");
-  }
-  const reader = response.body?.getReader();
-  if (reader === undefined) {
-    const bytes = new Uint8Array(await response.arrayBuffer());
-    assert(bytes.byteLength <= maxBytes, "Xiaomi MiMo response exceeds the configured limit");
-    return Buffer.from(bytes).toString("utf8");
-  }
-  const chunks: Uint8Array[] = [];
-  let size = 0;
-  while (true) {
-    const item = await reader.read();
-    if (item.done) break;
-    size += item.value.byteLength;
-    if (size > maxBytes) {
-      await reader.cancel();
-      throw new Error("Xiaomi MiMo response exceeds the configured limit");
-    }
-    chunks.push(item.value);
-  }
-  const bytes = new Uint8Array(size);
-  let offset = 0;
-  chunks.forEach((chunk) => { bytes.set(chunk, offset); offset += chunk.byteLength; });
-  return Buffer.from(bytes).toString("utf8");
-}
-
-export function createXiaomiMimoProvider(options: CreateXiaomiMimoProviderOptions) {
-  const apiBaseUrl = normalizeBaseUrl(options.apiBaseUrl ?? "https://api.xiaomimimo.com/v1");
-  const requestTimeoutMs = positiveInteger(options.requestTimeoutMs ?? 180_000, "requestTimeoutMs");
-  const maxResponseBytes = positiveInteger(options.maxResponseBytes ?? 64 * 1024 * 1024, "maxResponseBytes");
-  const maxVoiceReferenceBase64Bytes = positiveInteger(
-    options.maxVoiceReferenceBase64Bytes ?? 10_000_000,
-    "maxVoiceReferenceBase64Bytes",
-  );
-  const fetcher = options.fetch ?? globalThis.fetch;
-  const endpointCapabilities = modelNames.map((model) => ({
-    capability: capabilities[model],
-    returns: generationTypes.audioSet,
-    lifecycle: "immediate" as const,
-    handler: async (context: EndpointInvocationContext) => {
-      const req = request(context.need.constraints, model);
-      const text = scalar(req, model, "text")!;
-      const messages: Array<{ role: "user" | "assistant"; content: string }> = [];
-      const audio: Record<string, CanonicalValue> = { format: "wav" };
-      if (model === "mimo-v2.5-tts-voicedesign") {
-        messages.push({ role: "user", content: scalar(req, model, "voiceDescription")! });
-      } else {
-        const instruction = scalar(req, model, "instruction", false);
-        if (instruction !== undefined) messages.push({ role: "user", content: instruction });
-        audio.voice = await readVoiceReference(context, req, maxVoiceReferenceBase64Bytes);
-      }
-      messages.push({ role: "assistant", content: text });
-      const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(new Error("Xiaomi MiMo request timed out")), requestTimeoutMs);
-      let response: Response;
-      let responseText: string;
-      try {
-        response = await fetcher(`${apiBaseUrl}/chat/completions`, {
-          method: "POST",
-          headers: { "content-type": "application/json", "api-key": credential(context) },
-          body: JSON.stringify({ model, messages, audio }),
-          signal: controller.signal,
-        });
-        responseText = await limitedResponseText(response, maxResponseBytes);
-      } finally {
-        clearTimeout(timer);
-      }
-      if (!response.ok) throw new Error(`Xiaomi MiMo returned HTTP ${response.status}: ${responseText.slice(0, 300)}`);
-      const bytes = parseAudio(responseText, maxResponseBytes);
-      const artifact = await context.resources.put(bytes, "audio/wav");
-      const result = sealGeneratedAudioSet({ audios: [artifact] });
-      return { value: { kind: "inline" as const, value: result as unknown as CanonicalValue } };
-    },
-  }));
-
-  return defineEndpointPackage({
-    module: xiaomiMimoProviderModuleRef,
-    facet: "speech",
-    instance: options.instance ?? "xiaomi-mimo.default",
-    pool: options.pool ?? options.instance ?? "xiaomi-mimo.default",
-    pricing: { kind: "page", url: "https://mimo.mi.com/docs/en-US/pricing" },
-    credentials: { apiKey: options.apiKey ?? credentialRef("env", "MIMO_API_KEY") },
-    credentialInputs: { apiKey: { label: "Xiaomi MiMo API key" } },
-    defaultConcurrency: options.defaultConcurrency ?? 2,
-    capabilities: endpointCapabilities,
-  });
-}

package/packages/runtime/src/environment.ts

@@ -1,6 +0,0 @@
-export type RuntimeEnvironmentStore = {
-  /** Select this literal normalized configuration, changing it only when no Runtime work is active. */
-  use(config: string): Promise<void>;
-  /** Refuse work when this Runtime instance was assembled from a different active configuration. */
-  assert(config: string): Promise<void>;
-};

package/packages/semantic-track/README.md

@@ -1,21 +0,0 @@
-# @hypit/semantic-track
-
-`SemanticTrack` is the single global semantic-timeline fact. It is the continuous program skeleton:
-every item is a real segment-local `SemanticTake`, and global frame positions are the prefix sum of
-their normalized local frame counts. There are no gap items or empty items. A Take may carry only
-audio or only visual media; its word array may be empty. An empty Script Segment such as
-`<empty></empty>` can therefore retain a real media span and both Segment anchors without speech.
-An empty word array is not an empty Track item. Visual placement is deliberately not
-part of this semantic truth.
-
-The package exposes pure projections to `ProgramSpace` and `AudioTrack`, plus the
-selection/segment/moment lookup functions used by semantic components. It performs no media I/O,
-mixing, transcription or rendering.
-
-## Prepared material in a semantic window
-
-`projectSemanticMedia(track, window?)` returns each intersecting Take's `media`, `segmentId`, global
-`span` and local `source` frame span. The default window is the whole performance. An interval
-beginning inside a Take preserves its source offset. Audio-only Takes remain represented so the
-consumer can choose the streams it displays. This projection makes no layout or layering decisions;
-Media and custom visual components can consume the same prepared performance.

package/packages/semantic-track/src/activation.ts

@@ -1,8 +0,0 @@
-import { semanticTrackComponent, semanticTrackManifest } from "./index.js";
-
-export const hypitPackage = {
-  format: "hypit.node-package@1" as const,
-  modules: [{ manifest: semanticTrackManifest }],
-  components: [semanticTrackComponent],
-};
-export default hypitPackage;

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

@@ -1,24 +0,0 @@
-import type { ComponentPackage } from "@hypit/component-kit";
-import type { StoredValue } from "@hypit/protocol";
-import { canonicalize } from "@hypit/protocol";
-
-import { semanticTrackProducers, semanticTrackTypes } from "./manifest.js";
-import { assertSemanticTrackIdentity } from "./identity.js";
-import { projectSemanticAudioTrack, projectSemanticProgramSpace } from "./projection.js";
-import type { SemanticTrack } from "./types.js";
-
-function track(value: StoredValue | undefined): SemanticTrack {
-  if (value?.kind !== "inline") throw new Error("SemanticTrack must be inline.");
-  return value.value as unknown as SemanticTrack;
-}
-
-export const semanticTrackComponent = {
-  producers: [
-    { producer: semanticTrackProducers.projectProgramSpace, handler: ({ inputs }) => ({ outputs: { space: { kind: "inline", value: canonicalize(projectSemanticProgramSpace(track(inputs.track?.value))) } }, needs: {} }) },
-    { producer: semanticTrackProducers.projectAudio, handler: ({ inputs }) => ({ outputs: { audio: { kind: "inline", value: canonicalize(projectSemanticAudioTrack(track(inputs.track?.value))) } }, needs: {} }) },
-  ],
-  validators: [{
-    type: semanticTrackTypes.track,
-    handler: ({ value }) => assertSemanticTrackIdentity(track(value)),
-  }],
-} satisfies ComponentPackage;

package/packages/semantic-track/src/identity.ts

@@ -1,58 +0,0 @@
-import { assertSemanticTakeIdentity } from "@hypit/speech";
-
-import type { SemanticTrack, SemanticTrackSpan } from "./types.js";
-
-export function sealSemanticTrack(value: SemanticTrack): SemanticTrack {
-  const track = structuredClone(value);
-  assertSemanticTrackIdentity(track);
-  return track;
-}
-
-export function assertSemanticTrackIdentity(track: SemanticTrack): void {
-  if (!track.id.trim() || !track.narrativeId.trim() || track.items.length === 0) {
-    throw new Error("SemanticTrack must have identities and contain at least one item.");
-  }
-  const segmentIds = new Set<string>();
-  const tokenIds = new Set<string>();
-  const anchorIds = new Set<string>();
-  let frameRate: SemanticTrack["items"][number]["take"]["media"]["timeline"]["frameRate"] | undefined;
-  for (const item of track.items) {
-    assertSemanticTakeIdentity(item.take);
-    if (item.take.narrativeId !== track.narrativeId) {
-      throw new Error(`SemanticTrack ${track.id} mixes Narrative ${item.take.narrativeId} into ${track.narrativeId}.`);
-    }
-    const rate = item.take.media.timeline.frameRate;
-    if (frameRate === undefined) frameRate = rate;
-    else if (frameRate.numerator !== rate.numerator || frameRate.denominator !== rate.denominator) {
-      throw new Error("SemanticTrack items must use one frame rate.");
-    }
-    const segmentId = item.take.segment.segmentId;
-    if (segmentIds.has(segmentId)) throw new Error(`SemanticTrack repeats Segment ${segmentId}.`);
-    segmentIds.add(segmentId);
-    for (const token of item.take.tokens) {
-      if (tokenIds.has(token.tokenId)) throw new Error(`SemanticTrack repeats Token ${token.tokenId}.`);
-      tokenIds.add(token.tokenId);
-    }
-    for (const anchor of item.take.anchors) {
-      if (anchor.identity === "program:start" || anchor.identity === "program:end") {
-        throw new Error(`SemanticTake cannot declare reserved Program Anchor ${anchor.identity}.`);
-      }
-      if (anchorIds.has(anchor.identity)) throw new Error(`SemanticTrack repeats Anchor ${anchor.identity}.`);
-      anchorIds.add(anchor.identity);
-    }
-  }
-}
-
-export function semanticTrackSpans(track: SemanticTrack): readonly SemanticTrackSpan[] {
-  assertSemanticTrackIdentity(track);
-  let frame = 0;
-  return track.items.map((item) => {
-    const startFrame = frame;
-    frame += item.take.media.timeline.frameCount;
-    return { item, startFrame, endFrameExclusive: frame };
-  });
-}
-
-export function semanticTrackFrameCount(track: SemanticTrack): number {
-  return semanticTrackSpans(track).at(-1)!.endFrameExclusive;
-}

package/packages/semantic-track/src/index.ts

@@ -1,6 +0,0 @@
-export { semanticTrackComponent } from "./component.js";
-export { assertSemanticTrackIdentity, sealSemanticTrack, semanticTrackFrameCount, semanticTrackSpans } from "./identity.js";
-export { assertNarrativeMomentIdentity, assertNarrativeSelectionIdentity, momentFrame, segmentFrameSpan, selectionFrameSpan, semanticAnchorFrames, tokenFrameSpan } from "./location.js";
-export { semanticTrackDependency, semanticTrackManifest, semanticTrackModuleRef, semanticTrackProducers, semanticTrackSchema, semanticTrackTypes } from "./manifest.js";
-export { projectSemanticAudioTrack, projectSemanticProgramSpace, projectSemanticMedia } from "./projection.js";
-export type * from "./types.js";

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

@@ -1,38 +0,0 @@
-import { compositionDependency, compositionTypes } from "@hypit/composition";
-import { narrativeDependency } from "@hypit/narrative";
-import { programSpaceDependency, programSpaceTypes } from "@hypit/program-space";
-import type { ModuleManifest, ProducerRef, TypeRef, ValueSchema } from "@hypit/protocol";
-import { semanticTakeSchema, speechDependency } from "@hypit/speech";
-
-export const semanticTrackModuleRef = { name: "@hypit/semantic-track", version: "1" } as const;
-export const semanticTrackTypes = {
-  track: { module: semanticTrackModuleRef, name: "SemanticTrack" },
-} satisfies Record<string, TypeRef>;
-export const semanticTrackProducers = {
-  projectProgramSpace: { module: semanticTrackModuleRef, name: "project-program-space" },
-  projectAudio: { module: semanticTrackModuleRef, name: "project-audio-track" },
-} satisfies Record<string, ProducerRef>;
-
-const string = { kind: "string", minLength: 1 } as const;
-const object = (fields: Readonly<Record<string, { readonly schema: ValueSchema; readonly optional?: boolean }>>): ValueSchema => ({ kind: "object", fields });
-export const semanticTrackSchema: ValueSchema = object({
-  id: { schema: string },
-  narrativeId: { schema: string },
-  items: { schema: { kind: "array", minItems: 1, items: object({
-    take: { schema: semanticTakeSchema },
-  }) } },
-});
-
-export const semanticTrackManifest: ModuleManifest = {
-  format: "hypit.module@1",
-  name: semanticTrackModuleRef.name,
-  version: semanticTrackModuleRef.version,
-  dependencies: [speechDependency, narrativeDependency, programSpaceDependency, compositionDependency],
-  types: [{ name: semanticTrackTypes.track.name }],
-  capabilities: [],
-  producers: [
-    { name: semanticTrackProducers.projectProgramSpace.name, inputs: [{ name: "track", type: semanticTrackTypes.track }], outputs: [{ name: "space", type: programSpaceTypes.programSpace }], needs: [] },
-    { name: semanticTrackProducers.projectAudio.name, inputs: [{ name: "track", type: semanticTrackTypes.track }], outputs: [{ name: "audio", type: compositionTypes.audioTrack }], needs: [] },
-  ],
-};
-export const semanticTrackDependency = { module: semanticTrackModuleRef } as const;

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

@@ -1,26 +0,0 @@
-import type { SemanticTake } from "@hypit/speech";
-
-export type SemanticTrackItem = {
-  readonly take: SemanticTake;
-};
-
-/**
- * The continuous program skeleton. Every item is a real SemanticTake and the
- * global frame domain is exactly their prefix sum: no gap or empty item exists.
- */
-export type SemanticTrack = {
-  readonly id: string;
-  readonly narrativeId: string;
-  readonly items: readonly SemanticTrackItem[];
-};
-
-export type SemanticTrackSpan = {
-  readonly item: SemanticTrackItem;
-  readonly startFrame: number;
-  readonly endFrameExclusive: number;
-};
-
-export type LocatedFrameSpan = {
-  readonly startFrame: number;
-  readonly endFrameExclusive: number;
-};