@hypit/hypit 0.0.1 → 0.1.0

package/packages/svs/README.md

@@ -0,0 +1,37 @@
+# `@hypit/svs`
+
+Minimal official parameter-recipe Frontend normally used by `.svs` SourceUnits. The source must
+select it explicitly with `<?svml using="@hypit/svs@1"?>`; the suffix is only a human convention.
+
+The SVS Frontend reads a `<sheet version="1">` containing named rule blocks and emits one immutable generic
+`Recipe` Record per rule. It does not know Caption, Film, Track or Provider parameters and it does
+not implement CSS selectors, cascade or inheritance. A consuming package validates a Recipe's
+properties and lowers it into its own typed Program Record.
+
+Recipe values use the shared canonical value model: `null`, booleans, finite
+numbers and strings remain compact scalar values; lists and records use strict
+JSON array/object syntax. SVS only parses and serializes those shapes. The
+consuming domain package owns their schema and meaning.
+
+```svs
+<?svml using="@hypit/svs@1"?>
+<sheet version="1">
+ranking.column {
+  rank-colors: ["#ff3f56", "#ffa72d", "#eadc2a"];
+}
+</sheet>
+```
+
+Source import aliases are owned by Source Closure compilation. A rule `caption.alice` remains that
+relative public export; importing it as `studio` exposes `studio.caption.alice` without changing the
+Recipe Record identity.
+
+Each property ends with `;`. Duplicate properties in one rule and duplicate rule paths are errors.
+Bare words such as `cover` remain strings; use quoted strings when punctuation could conflict with
+the rule syntax. JSON arrays and objects require JSON quoting; they do not evaluate expressions or
+graph references. Units such as `8f` or `50%` remain string values until a consuming package interprets
+them. A consumer that needs graph media or font inputs takes explicit Source references separately.
+
+The Recipe Source's rule paths do not imply parent/child inheritance: `caption.base` and
+`caption.guest` are independent values. Any parameter defaults or overrides come from the declared
+consumer, such as TextTemplate's defaults/Recipe/Param precedence, not from SVS itself.

package/packages/svs/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@hypit/svs",
+  "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/core": "workspace:*",
+    "@hypit/elaborator": "workspace:*",
+    "@hypit/protocol": "workspace:*"
+  },
+  "devDependencies": {
+    "@hypit/markup": "workspace:*"
+  }
+}

package/packages/svs/src/activation.ts

@@ -0,0 +1,11 @@
+import { createAuthorFrontendHostFacet } from "@hypit/elaborator";
+
+import { svsFrontend, svsManifest } from "./index.js";
+
+export const hypitPackage = {
+  format: "hypit.node-package@1" as const,
+  modules: [{ manifest: svsManifest }],
+  hostFacets: [createAuthorFrontendHostFacet(svsFrontend)],
+};
+
+export default hypitPackage;

package/packages/svs/src/format.ts

@@ -0,0 +1,16 @@
+import type { CanonicalValue } from "@hypit/protocol";
+
+const BARE = /^[^\s;,\[\]{}"']+$/u;
+const NUMBER = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?$/u;
+
+/** Serialize one canonical value without knowing which component consumes it. */
+export function formatSvsValue(value: CanonicalValue): string {
+  if (value === null) return "null";
+  if (typeof value === "boolean" || typeof value === "number") return String(value);
+  if (typeof value === "string") {
+    return BARE.test(value) && value !== "null" && value !== "true" && value !== "false" && !NUMBER.test(value)
+      ? value
+      : JSON.stringify(value);
+  }
+  return JSON.stringify(value);
+}

package/packages/svs/src/frontend.ts

@@ -0,0 +1,33 @@
+import {
+  sealRecord,
+} from "@hypit/core";
+import type { AuthorFrontend, AuthorSourceExport } from "@hypit/elaborator";
+
+import { svsFrontendId, svsModuleRef, svsRecipeType } from "./manifest.js";
+import { parseSvs } from "./parser.js";
+
+export const svsFrontend: AuthorFrontend = {
+  id: svsFrontendId,
+  discover() {
+    return { modules: [`${svsModuleRef.name}@${svsModuleRef.version}`], sources: [] };
+  },
+  decode(source, context) {
+    const parsed = parseSvs(source.name, source.text);
+    const records = parsed.recipes.map((recipe) => sealRecord({
+      id: recipe.value.path,
+      type: svsRecipeType,
+      value: { kind: "inline", value: recipe.value },
+    }));
+    const exports: AuthorSourceExport[] = records.map((record) => ({
+      name: record.id,
+      ref: { kind: "record", id: record.id },
+      type: record.type,
+    }));
+    return {
+      records,
+      components: [],
+      fragments: [],
+      exports,
+    };
+  },
+};

package/packages/svs/src/index.ts

@@ -0,0 +1,5 @@
+export { svsFrontendId, svsManifest, svsModuleRef, svsRecipeType } from "./manifest.js";
+export { SvsSyntaxError, parseSvs } from "./parser.js";
+export { formatSvsValue } from "./format.js";
+export { svsFrontend } from "./frontend.js";
+export type * from "./types.js";

package/packages/svs/src/manifest.ts

@@ -0,0 +1,17 @@
+import type { ModuleManifest, TypeRef } from "@hypit/protocol";
+
+export const svsModuleRef = { name: "@hypit/svs", version: "1" } as const;
+export const svsRecipeType = { module: svsModuleRef, name: "Recipe" } satisfies TypeRef;
+export const svsFrontendId = "@hypit/svs@1";
+
+export const svsManifest: ModuleManifest = {
+  format: "hypit.module@1",
+  name: svsModuleRef.name,
+  version: svsModuleRef.version,
+  dependencies: [],
+  types: [{
+    name: svsRecipeType.name,
+  }],
+  capabilities: [],
+  producers: [],
+};

package/packages/svs/src/parser.ts

@@ -0,0 +1,279 @@
+import type { CanonicalValue } from "@hypit/protocol";
+
+import type {
+  ParsedSvsProperty,
+  ParsedSvsRecipe,
+  ParsedSvsSheet,
+  SvsRecipe,
+} from "./types.js";
+
+const RULE = /^[a-z][a-z0-9_-]*(?:\.[a-z][a-z0-9_-]*)+/u;
+const PROPERTY = /^[a-z][a-z0-9-]*/u;
+const SHEET_ID = /^[a-z][a-z0-9_-]{0,63}$/u;
+
+export class SvsSyntaxError extends Error {
+  readonly code: string;
+  readonly sourceName: string;
+  readonly offset: number;
+
+  constructor(code: string, message: string, sourceName: string, offset: number) {
+    super(`${sourceName}:${offset}: ${message}`);
+    this.name = "SvsSyntaxError";
+    this.code = code;
+    this.sourceName = sourceName;
+    this.offset = offset;
+  }
+}
+
+function fail(sourceName: string, code: string, message: string, offset: number): never {
+  throw new SvsSyntaxError(code, message, sourceName, offset);
+}
+
+function withoutComments(sourceName: string, text: string): string {
+  const output = [...text];
+  let cursor = 0;
+  let quote: "\"" | "'" | undefined;
+  let escaped = false;
+  while (cursor < text.length) {
+    const character = text[cursor];
+    if (escaped) {
+      escaped = false;
+      cursor += 1;
+      continue;
+    }
+    if (character === "\\" && quote !== undefined) {
+      escaped = true;
+      cursor += 1;
+      continue;
+    }
+    if (quote !== undefined) {
+      if (character === quote) quote = undefined;
+      cursor += 1;
+      continue;
+    }
+    if (character === "\"" || character === "'") {
+      quote = character;
+      cursor += 1;
+      continue;
+    }
+    if (!text.startsWith("/*", cursor)) {
+      cursor += 1;
+      continue;
+    }
+    const end = text.indexOf("*/", cursor + 2);
+    if (end < 0) fail(sourceName, "SVS_COMMENT_UNCLOSED", "Unclosed comment.", cursor);
+    for (let index = cursor; index < end + 2; index += 1) {
+      if (output[index] !== "\n" && output[index] !== "\r") output[index] = " ";
+    }
+    cursor = end + 2;
+  }
+  return output.join("");
+}
+
+function closingBrace(text: string, start: number, limit: number): number {
+  let quote: "\"" | "'" | undefined;
+  let escaped = false;
+  let nested = 0;
+  for (let cursor = start; cursor < limit; cursor += 1) {
+    const character = text[cursor];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (character === "\\" && quote !== undefined) {
+      escaped = true;
+      continue;
+    }
+    if (quote !== undefined) {
+      if (character === quote) quote = undefined;
+      continue;
+    }
+    if (character === "\"" || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (character === "{") {
+      nested += 1;
+      continue;
+    }
+    if (character === "}") {
+      if (nested === 0) return cursor;
+      nested -= 1;
+    }
+  }
+  return -1;
+}
+
+function skipSpace(text: string, start: number): number {
+  let cursor = start;
+  while (/\s/u.test(text[cursor] ?? "")) cursor += 1;
+  return cursor;
+}
+
+function parseAttributes(
+  sourceName: string,
+  raw: string,
+  offset: number,
+): Readonly<Record<string, string>> {
+  const attributes: Record<string, string> = {};
+  const attribute = /([a-z][a-z0-9-]*)\s*=\s*(["'])(.*?)\2/gu;
+  let cursor = 0;
+  for (const match of raw.matchAll(attribute)) {
+    const start = match.index ?? 0;
+    if (raw.slice(cursor, start).trim().length > 0) {
+      fail(sourceName, "SVS_SHEET_ATTRIBUTE", "Malformed <sheet> attribute.", offset + cursor);
+    }
+    const name = match[1] as string;
+    if (Object.hasOwn(attributes, name)) {
+      fail(sourceName, "SVS_SHEET_ATTRIBUTE_DUPLICATE", `Duplicate sheet attribute ${name}.`, offset + start);
+    }
+    attributes[name] = match[3] as string;
+    cursor = start + match[0].length;
+  }
+  if (raw.slice(cursor).trim().length > 0) {
+    fail(sourceName, "SVS_SHEET_ATTRIBUTE", "Malformed <sheet> attribute.", offset + cursor);
+  }
+  const unknown = Object.keys(attributes).filter((name) => name !== "version" && name !== "id");
+  if (unknown.length > 0) fail(sourceName, "SVS_SHEET_ATTRIBUTE", `Unknown sheet attribute ${unknown[0]}.`, offset);
+  if (attributes.version !== "1") fail(sourceName, "SVS_VERSION", '<sheet> requires version="1".', offset);
+  if (attributes.id !== undefined && !SHEET_ID.test(attributes.id)) {
+    fail(sourceName, "SVS_SHEET_ID", "Sheet id must be a canonical lower-case identifier.", offset);
+  }
+  return attributes;
+}
+
+function parseValue(sourceName: string, text: string, offset: number): CanonicalValue {
+  const value = text.trim();
+  if (value.length === 0) fail(sourceName, "SVS_VALUE_EMPTY", "Recipe property value is empty.", offset);
+  if (value === "null") return null;
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (/^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?$/u.test(value)) return Number(value);
+  if (value.startsWith("[") || value.startsWith("{")) {
+    try {
+      return JSON.parse(value) as CanonicalValue;
+    } catch {
+      fail(sourceName, "SVS_VALUE_STRUCTURED", "Structured Recipe values must use JSON array/object syntax.", offset);
+    }
+  }
+  if (
+    (value.startsWith('"') && value.endsWith('"'))
+    || (value.startsWith("'") && value.endsWith("'"))
+  ) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+
+function valueSemicolon(text: string, start: number): number {
+  let quote: "\"" | "'" | undefined;
+  let escaped = false;
+  for (let cursor = start; cursor < text.length; cursor += 1) {
+    const character = text[cursor];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (character === "\\" && quote !== undefined) {
+      escaped = true;
+      continue;
+    }
+    if (quote !== undefined) {
+      if (character === quote) quote = undefined;
+      continue;
+    }
+    if (character === "\"" || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (character === ";") return cursor;
+  }
+  return -1;
+}
+
+function parseProperties(
+  sourceName: string,
+  text: string,
+  offset: number,
+): {
+  readonly values: Readonly<Record<string, CanonicalValue>>;
+  readonly parsed: readonly ParsedSvsProperty[];
+} {
+  const properties: Record<string, CanonicalValue> = {};
+  const parsed: ParsedSvsProperty[] = [];
+  let cursor = 0;
+  while (cursor < text.length) {
+    cursor = skipSpace(text, cursor);
+    if (cursor >= text.length) break;
+    const propertyStart = cursor;
+    const match = PROPERTY.exec(text.slice(cursor));
+    if (!match) fail(sourceName, "SVS_PROPERTY", "Expected a recipe property.", offset + cursor);
+    const name = match[0];
+    if (Object.hasOwn(properties, name)) {
+      fail(sourceName, "SVS_PROPERTY_DUPLICATE", `Duplicate property ${name}.`, offset + cursor);
+    }
+    cursor += name.length;
+    cursor = skipSpace(text, cursor);
+    if (text[cursor] !== ":") fail(sourceName, "SVS_PROPERTY_COLON", `Property ${name} requires ':'.`, offset + cursor);
+    const valueStart = cursor + 1;
+    const semicolon = valueSemicolon(text, valueStart);
+    if (semicolon < 0) fail(sourceName, "SVS_PROPERTY_SEMICOLON", `Property ${name} requires ';'.`, offset + valueStart);
+    properties[name] = parseValue(sourceName, text.slice(valueStart, semicolon), offset + valueStart);
+    let trimmedStart = valueStart;
+    let trimmedEnd = semicolon;
+    while (/\s/u.test(text[trimmedStart] ?? "")) trimmedStart += 1;
+    while (trimmedEnd > trimmedStart && /\s/u.test(text[trimmedEnd - 1] ?? "")) trimmedEnd -= 1;
+    parsed.push({
+      name,
+      range: { start: offset + propertyStart, end: offset + semicolon + 1 },
+      valueRange: { start: offset + trimmedStart, end: offset + trimmedEnd },
+    });
+    cursor = semicolon + 1;
+  }
+  return { values: properties, parsed };
+}
+
+export function parseSvs(sourceName: string, source: string): ParsedSvsSheet {
+  const text = withoutComments(sourceName, source);
+  let cursor = skipSpace(text, 0);
+  if (!text.startsWith("<sheet", cursor)) fail(sourceName, "SVS_ROOT", "Source must open with <sheet>.", cursor);
+  const openEnd = text.indexOf(">", cursor + 6);
+  if (openEnd < 0) fail(sourceName, "SVS_ROOT", "Opening <sheet> is not closed.", cursor);
+  const attributes = parseAttributes(sourceName, text.slice(cursor + 6, openEnd), cursor + 6);
+  cursor = openEnd + 1;
+  const close = text.indexOf("</sheet>", cursor);
+  if (close < 0) fail(sourceName, "SVS_ROOT_UNCLOSED", "Source is missing </sheet>.", source.length);
+  if (text.slice(close + "</sheet>".length).trim().length > 0) {
+    fail(sourceName, "SVS_TRAILING", "Only trivia may follow </sheet>.", close + "</sheet>".length);
+  }
+  const recipes: ParsedSvsRecipe[] = [];
+  const paths = new Set<string>();
+  while (cursor < close) {
+    cursor = skipSpace(text, cursor);
+    if (cursor >= close) break;
+    const match = RULE.exec(text.slice(cursor));
+    if (!match) fail(sourceName, "SVS_RULE", "Expected a dotted recipe path.", cursor);
+    const path = match[0];
+    if (paths.has(path)) fail(sourceName, "SVS_RULE_DUPLICATE", `Duplicate recipe ${path}.`, cursor);
+    paths.add(path);
+    const start = cursor;
+    cursor += path.length;
+    cursor = skipSpace(text, cursor);
+    if (text[cursor] !== "{") fail(sourceName, "SVS_RULE_OPEN", `Recipe ${path} requires '{'.`, cursor);
+    const blockStart = cursor + 1;
+    const blockEnd = closingBrace(text, blockStart, close);
+    if (blockEnd < 0 || blockEnd > close) fail(sourceName, "SVS_RULE_UNCLOSED", `Recipe ${path} is not closed.`, start);
+    const parsedProperties = parseProperties(sourceName, text.slice(blockStart, blockEnd), blockStart);
+    const value: SvsRecipe = {
+
+      path,
+      properties: parsedProperties.values,
+    };
+    recipes.push({ value, range: { start, end: blockEnd + 1 }, properties: parsedProperties.parsed });
+    cursor = blockEnd + 1;
+  }
+  return {
+    ...(attributes.id === undefined ? {} : { id: attributes.id }),
+    recipes,
+  };
+}

package/packages/svs/src/types.ts

@@ -0,0 +1,26 @@
+import type { CanonicalValue, SourceRange } from "@hypit/protocol";
+
+export type SvsRecipe = {
+  readonly path: string;
+  readonly properties: Readonly<Record<string, CanonicalValue>>;
+};
+
+export type ParsedSvsRecipe = {
+  readonly value: SvsRecipe;
+  readonly range: SourceRange;
+  /** Exact author-source spans, for editors that must preserve surrounding trivia. */
+  readonly properties: readonly ParsedSvsProperty[];
+};
+
+export type ParsedSvsProperty = {
+  readonly name: string;
+  /** From the property name through its terminating semicolon. */
+  readonly range: SourceRange;
+  /** The trimmed value only; replacing this span preserves author formatting. */
+  readonly valueRange: SourceRange;
+};
+
+export type ParsedSvsSheet = {
+  readonly id?: string;
+  readonly recipes: readonly ParsedSvsRecipe[];
+};

package/packages/temporal/README.md

@@ -0,0 +1,31 @@
+# `@hypit/temporal`
+
+Runtime protocol for projected video time.
+
+The public values are `TemporalInstant` and `TemporalWindow`. An Instant retains its runtime source,
+exact projection expression, resolved ProgramSpace frame and author authority. A Window is composed
+from two independently traced Instants; it has no synthetic single source.
+
+Every source names its exact `ProgramSpace`; semantic sources also name their `Narrative`. Every projection retains the
+consumer's public domain identity as `subjectId`. These are public provenance fields, not generated hashes
+or editor metadata. A graph-qualified projection `id` and its author-facing `subjectId` are separate
+on purpose.
+
+Author syntax does not live here. `@hypit/temporal-markup` lowers SVML timing forms into ordinary
+Instant projection and Window composition operations. The graph supplies ProgramSpace separately;
+domain components receive only ProgramSpace plus the resulting Instant or Window and never locate a
+Selection, Segment or Moment themselves.
+
+Every official consumer verifies the projection at its public boundary: `subjectId` must name the
+domain object being built, both endpoints must retain one ProgramSpace, and that identity
+must equal the explicitly supplied ProgramSpace. ProgramSpace is therefore an ordinary graph input
+to the consumer, not ambient renderer state.
+
+Temporal rejects Instants outside ProgramSpace and Windows that are reversed or empty. It does not
+clip or repair author time. The package also provides sibling-window validation and triggered-stage
+scheduling, but no renderer, Provider, media policy or Studio behavior.
+
+Program-bound projection receives ProgramSpace directly. Semantic-bound projection receives the
+SemanticTrack that locates its Script anchors. Both produce the same Instant type; program-bound
+sources have no Narrative identity. A Window can combine a semantic endpoint with a program endpoint
+on the same time axis. `absolute` expressions may include a duration offset, as used by `at`/`for`.

package/packages/temporal/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@hypit/temporal",
+  "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/component-kit": "workspace:*",
+    "@hypit/narrative": "workspace:*",
+    "@hypit/program-space": "workspace:*",
+    "@hypit/protocol": "workspace:*",
+    "@hypit/semantic-track": "workspace:*"
+  }
+}

package/packages/temporal/src/activation.ts

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

package/packages/temporal/src/component.ts

@@ -0,0 +1,68 @@
+import type { ComponentPackage, ProducerHandlerContext } from "@hypit/component-kit";
+import { canonicalize } from "@hypit/protocol";
+import type { StoredValue } from "@hypit/protocol";
+import type { NarrativeExcerpt, NarrativeMomentRef, NarrativeSelectionRef } from "@hypit/narrative";
+import type { ProgramSpace } from "@hypit/program-space";
+import type { SemanticTrack } from "@hypit/semantic-track";
+
+import {
+  composeTemporalWindow,
+  projectMomentInstant,
+  projectProgramInstant,
+  projectSegmentInstant,
+  projectSelectionInstant,
+} from "./projection.js";
+import { temporalProducers } from "./index.js";
+import type { ProjectedInstant, TemporalInstantSpec, TemporalWindowSpec } from "./types.js";
+
+function inline<T>(value: StoredValue | undefined, label: string): T {
+  if (value?.kind !== "inline") throw new Error(`${label} must be inline.`);
+  return value.value as unknown as T;
+}
+
+const output = (value: unknown) => ({ kind: "inline" as const, value: canonicalize(value) });
+
+function instantSpec(inputs: ProducerHandlerContext["inputs"]): TemporalInstantSpec {
+  return inline<TemporalInstantSpec>(inputs.spec?.value, "TemporalInstantSpec");
+}
+
+export const temporalComponent = {
+  producers: [
+    { producer: temporalProducers.projectProgramInstant, handler: ({ inputs }) => ({ outputs: { instant: output(projectProgramInstant({
+      itemId: instantSpec(inputs).id,
+      subjectId: instantSpec(inputs).subjectId,
+      space: inline<ProgramSpace>(inputs.space?.value, "ProgramSpace"),
+      projection: instantSpec(inputs).projection,
+      authority: instantSpec(inputs).authority,
+    })) }, needs: {} }) },
+    { producer: temporalProducers.projectSelectionInstant, handler: ({ inputs }) => ({ outputs: { instant: output(projectSelectionInstant({
+      itemId: instantSpec(inputs).id,
+      subjectId: instantSpec(inputs).subjectId,
+      semantic: inline<SemanticTrack>(inputs.semantic?.value, "SemanticTrack"),
+      selection: inline<NarrativeSelectionRef>(inputs.selection?.value, "NarrativeSelection"),
+      projection: instantSpec(inputs).projection,
+      authority: instantSpec(inputs).authority,
+    })) }, needs: {} }) },
+    { producer: temporalProducers.projectSegmentInstant, handler: ({ inputs }) => ({ outputs: { instant: output(projectSegmentInstant({
+      itemId: instantSpec(inputs).id,
+      subjectId: instantSpec(inputs).subjectId,
+      semantic: inline<SemanticTrack>(inputs.semantic?.value, "SemanticTrack"),
+      segment: inline<NarrativeExcerpt>(inputs.segment?.value, "NarrativeExcerpt"),
+      projection: instantSpec(inputs).projection,
+      authority: instantSpec(inputs).authority,
+    })) }, needs: {} }) },
+    { producer: temporalProducers.projectMomentInstant, handler: ({ inputs }) => ({ outputs: { instant: output(projectMomentInstant({
+      itemId: instantSpec(inputs).id,
+      subjectId: instantSpec(inputs).subjectId,
+      semantic: inline<SemanticTrack>(inputs.semantic?.value, "SemanticTrack"),
+      moment: inline<NarrativeMomentRef>(inputs.moment?.value, "NarrativeMoment"),
+      projection: instantSpec(inputs).projection,
+      authority: instantSpec(inputs).authority,
+    })) }, needs: {} }) },
+    { producer: temporalProducers.composeWindow, handler: ({ inputs }) => ({ outputs: { window: output(composeTemporalWindow(
+      inline<TemporalWindowSpec>(inputs.spec?.value, "TemporalWindowSpec"),
+      inline<ProjectedInstant>(inputs.start?.value, "TemporalInstant start"),
+      inline<ProjectedInstant>(inputs.end?.value, "TemporalInstant end"),
+    )) }, needs: {} }) },
+  ],
+} satisfies ComponentPackage;