@hypit/hypit 0.0.1 → 0.1.0

package/packages/program-space/src/activation.ts

@@ -0,0 +1,19 @@
+import { createMarkupSurfaceHostFacet } from "@hypit/markup";
+
+import { decodeClockSurface, decodeSpaceSurface } from "./surface.js";
+import { programSpaceManifest, programSpaceMarkupSurfaces, programSpaceModuleRef } from "./index.js";
+
+export const hypitPackage = {
+  format: "hypit.node-package@1" as const,
+  modules: [{ manifest: programSpaceManifest }],
+  hostFacets: [createMarkupSurfaceHostFacet({
+    module: programSpaceModuleRef,
+    declaration: programSpaceMarkupSurfaces.find((item) => item.name === "clock")!,
+    handler: decodeClockSurface,
+  }), createMarkupSurfaceHostFacet({
+    module: programSpaceModuleRef,
+    declaration: programSpaceMarkupSurfaces.find((item) => item.name === "space")!,
+    handler: decodeSpaceSurface,
+  })],
+};
+export default hypitPackage;

package/packages/program-space/src/index.ts

@@ -0,0 +1,107 @@
+import type { ModuleManifest, TypeRef, ValueSchema } from "@hypit/protocol";
+
+export type ProgramClock = {
+  readonly frameRate: { readonly numerator: number; readonly denominator: number };
+};
+
+export type ProgramSpace = {
+  /** Author-visible identity of this film time axis. */
+  readonly id: string;
+  readonly durationSec: number;
+  readonly frameRate: { readonly numerator: number; readonly denominator: number };
+};
+
+export const programSpaceModuleRef = { name: "@hypit/program-space", version: "1" } as const;
+export const programSpaceTypes = {
+  programSpace: { module: programSpaceModuleRef, name: "ProgramSpace" },
+  clock: { module: programSpaceModuleRef, name: "ProgramClock" },
+} satisfies Record<string, TypeRef>;
+const number = { kind: "number", minimum: 0 } as const;
+const integer = { kind: "number", integer: true, minimum: 0 } as const;
+const string = { kind: "string", minLength: 1 } as const;
+export const programSpaceSchema: ValueSchema = {
+  kind: "object",
+  fields: {
+    id: { schema: string },
+    durationSec: { schema: number },
+    frameRate: { schema: { kind: "object", fields: {
+      numerator: { schema: integer }, denominator: { schema: integer },
+    } } },
+  },
+};
+export const programSpaceManifest: ModuleManifest = {
+  format: "hypit.module@1", name: programSpaceModuleRef.name, version: programSpaceModuleRef.version,
+  dependencies: [], types: [
+    { name: programSpaceTypes.programSpace.name },
+    { name: programSpaceTypes.clock.name },
+  ],
+  capabilities: [], producers: [],
+};
+export const programSpaceDependency = { module: programSpaceModuleRef } as const;
+export const programSpaceMarkupSurfaces = [
+  { name: "clock", tag: "Clock", mode: "structured", outputs: [programSpaceTypes.clock] },
+  { name: "space", tag: "Space", mode: "structured", outputs: [programSpaceTypes.programSpace],
+    vocabulary: {
+      summary: "Declares a film's frame rate and authored duration, for animation whose timing is directed without a performance.",
+      attributes: [
+        { name: "id", kind: "identifier", required: true, summary: "Names the shared film time axis." },
+        { name: "frame-rate", kind: "literal", required: true, summary: "Frames per second, such as 30 or 30000/1001." },
+        { name: "duration", kind: "literal", required: true, summary: "Total duration in seconds, milliseconds or frames, such as 8s or 240f; ends on a frame boundary." },
+      ],
+      example: '<time:Space id="animation" frame-rate="30" duration="8s"/>',
+    },
+  },
+] as const;
+
+export function sealProgramClock(value: ProgramClock): ProgramClock {
+  assertProgramClockIdentity(value);
+  return structuredClone(value);
+}
+
+export function assertProgramClockIdentity(clock: ProgramClock): void {
+  const { numerator, denominator } = clock.frameRate;
+  if (!Number.isSafeInteger(numerator) || numerator <= 0
+    || !Number.isSafeInteger(denominator) || denominator <= 0) {
+    throw new Error("ProgramClock is invalid.");
+  }
+}
+
+export function sealProgramSpace(value: ProgramSpace): ProgramSpace { return structuredClone(value); }
+
+export function programSpaceFrameCount(programSpace: ProgramSpace): number {
+  const frames = programSpace.durationSec * programSpace.frameRate.numerator / programSpace.frameRate.denominator;
+  const rounded = Math.round(frames);
+  if (!Number.isSafeInteger(rounded) || rounded < 1 || Math.abs(frames - rounded) > 1e-7) {
+    throw new Error("ProgramSpace duration must end on an exact frame boundary.");
+  }
+  return rounded;
+}
+export function programSpaceSampleFrames(programSpace: ProgramSpace, sampleRate: number): number {
+  const frames = programSpaceFrameCount(programSpace);
+  return programFrameSampleBoundary(programSpace, frames, sampleRate);
+}
+export function programFrameSampleBoundary(
+  programSpace: ProgramSpace,
+  frame: number,
+  sampleRate: number,
+): number {
+  const frames = programSpaceFrameCount(programSpace);
+  if (!Number.isSafeInteger(frame) || frame < 0 || frame > frames) {
+    throw new Error("ProgramSpace frame boundary is invalid.");
+  }
+  if (!Number.isSafeInteger(sampleRate) || sampleRate <= 0) throw new Error("ProgramSpace sample rate is invalid.");
+  const numerator = BigInt(frame) * BigInt(sampleRate) * BigInt(programSpace.frameRate.denominator);
+  const denominator = BigInt(programSpace.frameRate.numerator);
+  const value = (numerator * 2n + denominator) / (denominator * 2n);
+  if (value < 0n || value > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error("ProgramSpace sample domain exceeds safe arithmetic.");
+  return Number(value);
+}
+export function assertProgramSpaceIdentity(programSpace: ProgramSpace): void {
+  const { numerator, denominator } = programSpace.frameRate;
+  if (!programSpace.id.trim()
+    || !Number.isSafeInteger(numerator) || numerator <= 0 || !Number.isSafeInteger(denominator)
+    || denominator <= 0 || !Number.isFinite(programSpace.durationSec) || programSpace.durationSec <= 0) {
+    throw new Error("ProgramSpace is invalid.");
+  }
+  programSpaceFrameCount(programSpace);
+}

package/packages/program-space/src/surface.ts

@@ -0,0 +1,55 @@
+import {
+  assertEmptyElement as empty,
+  textAttribute as text,
+  type StructuredElement,
+  type StructuredSurfaceHandler,
+} from "@hypit/markup";
+
+import { assertProgramSpaceIdentity, programSpaceTypes, sealProgramClock, type ProgramClock } from "./index.js";
+
+function frameRate(element: StructuredElement): ProgramClock["frameRate"] {
+  const value = text(element, "frame-rate");
+  const match = /^(\d+)(?:\/(\d+))?$/u.exec(value);
+  if (match === null) throw new Error(`${element.name}.frame-rate must be a positive rational such as 30 or 30000/1001.`);
+  const numerator = Number(match[1]);
+  const denominator = Number(match[2] ?? "1");
+  if (!Number.isSafeInteger(numerator) || numerator < 1
+    || !Number.isSafeInteger(denominator) || denominator < 1) {
+    throw new Error(`${element.name}.frame-rate is invalid.`);
+  }
+  return { numerator, denominator };
+}
+
+export const decodeClockSurface: StructuredSurfaceHandler = ({ element }) => {
+  const expected = ["frame-rate", "id"];
+  if (Object.keys(element.attributes).sort().join("\0") !== expected.join("\0")) {
+    throw new Error(`${element.name} requires exactly id and frame-rate.`);
+  }
+  empty(element);
+  const id = text(element, "id");
+  const clock = sealProgramClock({ frameRate: frameRate(element) });
+  return {
+    records: [{ id, type: programSpaceTypes.clock, value: { kind: "inline", value: clock }, range: element.range }],
+    components: [],
+    fragments: [],
+  };
+};
+
+export const decodeSpaceSurface: StructuredSurfaceHandler = ({ element }) => {
+  const expected = ["duration", "frame-rate", "id"];
+  if (Object.keys(element.attributes).sort().join("\0") !== expected.join("\0")) {
+    throw new Error(`${element.name} requires exactly id, frame-rate and duration.`);
+  }
+  empty(element);
+  const id = text(element, "id");
+  const rate = frameRate(element);
+  const duration = text(element, "duration");
+  const match = /^(\d+(?:\.\d+)?)(s|ms|f)$/u.exec(duration);
+  if (match === null) throw new Error(`${element.name}.duration must be a duration such as 8s, 8000ms or 240f.`);
+  const value = Number(match[1]);
+  const durationSec = match[2] === "f" ? value * rate.denominator / rate.numerator
+    : match[2] === "ms" ? value / 1000 : value;
+  const space = { id, durationSec, frameRate: rate };
+  assertProgramSpaceIdentity(space);
+  return { records: [{ id, type: programSpaceTypes.programSpace, value: { kind: "inline", value: space }, range: element.range }], components: [], fragments: [] };
+};

package/packages/protocol/README.md

@@ -0,0 +1,11 @@
+# `@hypit/protocol`
+
+Data contracts shared across package boundaries.
+
+This package defines module manifests, nominal references, typed values, author and run graphs,
+build plans, Core commands, command results, build facts and build state. It also parses a module
+manifest from JSON without loading executable package code.
+
+Protocol contains no source parser, package loader, runtime, filesystem access or video vocabulary.
+Packages own their types, producers and capabilities by module name and version. Core and Hosts
+communicate through those names and the values declared here.

package/packages/protocol/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@hypit/protocol",
+  "version": "0.0.0-dev",
+  "license": "SEE LICENSE IN LICENSE",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  }
+}

package/packages/protocol/src/build-id.ts

@@ -0,0 +1,52 @@
+function assert(condition: unknown, message: string): asserts condition {
+  if (!condition) throw new Error(message);
+}
+
+const ORDERED_BUILD_ID = /^bld_(\d{8}T\d{9}Z)_([0-9A-Z]{10})$/u;
+
+function timestampText(value: number): string {
+  assert(Number.isSafeInteger(value) && value >= 0, "Build time must be a non-negative safe integer");
+  return new Date(value).toISOString()
+    .replace(/[-:.]/gu, "")
+    .replace(/(\d{8}T\d{6})(\d{3})Z/u, "$1$2Z");
+}
+
+/**
+ * Create the one public, chronologically sortable Build identity form.
+ *
+ * The nonce exists only to keep independent submissions in the same millisecond distinct. It is
+ * not a content digest and has no reuse, equality or storage semantics.
+ */
+export function orderedBuildId(createdAt: number, nonce: string): string {
+  assert(/^[0-9A-Z]{10}$/u.test(nonce), "Build nonce must be ten upper-case alphanumeric characters");
+  return `bld_${timestampText(createdAt)}_${nonce}`;
+}
+
+/** Submission time carried by an ordered Build id, or undefined for a non-public/internal id. */
+export function buildIdCreatedAt(value: string): number | undefined {
+  const match = ORDERED_BUILD_ID.exec(value);
+  if (match === null) return undefined;
+  const raw = match[1]!;
+  const iso = `${raw.slice(0, 4)}-${raw.slice(4, 6)}-${raw.slice(6, 8)}`
+    + `T${raw.slice(9, 11)}:${raw.slice(11, 13)}:${raw.slice(13, 15)}.${raw.slice(15, 18)}Z`;
+  const createdAt = Date.parse(iso);
+  return Number.isFinite(createdAt) && timestampText(createdAt) === raw ? createdAt : undefined;
+}
+
+export function assertOrderedBuildId(value: string): void {
+  assertBuildId(value);
+  assert(buildIdCreatedAt(value) !== undefined,
+    "Build id must contain its UTC submission time and a ten-character nonce");
+}
+
+/**
+ * Runtime Build ids are opaque identities, but every durable Host currently
+ * uses one id as one filesystem/S3 path segment. Keep that boundary explicit:
+ * an id is never a path and the two dot directory entries are never Builds.
+ */
+export function assertBuildId(value: string): void {
+  assert(value.length > 0 && value === value.trim(), "Build id must be a non-empty unpadded name");
+  assert(value !== "." && value !== "..", "Build id must not be a dot directory");
+  assert(!value.includes("/") && !value.includes("\\") && !value.includes("\0"),
+    "Build id must be one path-free name");
+}

package/packages/protocol/src/build.ts

@@ -0,0 +1,265 @@
+import type {
+  CandidateId,
+  CommandId,
+  CapabilityRef,
+  LogicalOutputId,
+  NeedId,
+  OperationId,
+  ProducerRef,
+  RecordId,
+  StepId,
+  TypeRef,
+} from "./identity.js";
+import type { ResolvedModuleClosure } from "./module.js";
+import type { CanonicalValue, StoredValue } from "./value.js";
+
+export type SourceRange = {
+  readonly start: number;
+  readonly end: number;
+};
+
+/** One typed value in the graph; semantic validation happens at the Host admission boundary. */
+export type TypedRecord = {
+  readonly id: RecordId;
+  readonly type: TypeRef;
+  readonly value: StoredValue;
+};
+
+export type Need = {
+  readonly id: NeedId;
+  readonly capability: CapabilityRef;
+  readonly returns: TypeRef;
+  readonly constraints: CanonicalValue;
+  readonly result: RecordId;
+};
+
+export type NeedBinding = {
+  readonly id: NeedId;
+  readonly result: RecordId;
+};
+
+export type RecordRef = {
+  readonly kind: "record";
+  readonly id: RecordId;
+};
+
+export type LogicalOutputRef = {
+  readonly kind: "logical-output";
+  readonly id: LogicalOutputId;
+};
+
+export type OperationResultRef = {
+  readonly kind: "operation-result";
+  readonly operation: OperationId;
+};
+
+export type GraphValueRef = RecordRef | LogicalOutputRef | OperationResultRef;
+
+export type LogicalOutput = {
+  readonly id: LogicalOutputId;
+  readonly type: TypeRef;
+  readonly primary: CandidateId;
+};
+
+export type OperationResult =
+  | {
+      readonly kind: "output";
+      readonly name: string;
+      readonly record: RecordId;
+    }
+  | {
+      readonly kind: "need";
+      readonly name: string;
+      readonly id: NeedId;
+      readonly record: RecordId;
+    };
+
+export type OperationNode = {
+  readonly id: OperationId;
+  readonly producer: ProducerRef;
+  readonly inputs: Readonly<Record<string, GraphValueRef>>;
+  readonly result: OperationResult;
+};
+
+export type ProvidedValue = {
+  readonly id: RecordId;
+  readonly value: StoredValue;
+};
+
+export type CandidateRoot =
+  | { readonly kind: "value"; readonly value: ProvidedValue }
+  | { readonly kind: "operation"; readonly result: OperationResultRef };
+
+export type Candidate = {
+  readonly id: CandidateId;
+  /** Type of the independent value exported by the Author or Run Graph. */
+  readonly type: TypeRef;
+  readonly root: CandidateRoot;
+};
+
+export type CompiledGraph = {
+  readonly format: "hypit.graph@1";
+  readonly outputs: readonly LogicalOutput[];
+  readonly candidates: readonly Candidate[];
+  readonly operations: readonly OperationNode[];
+};
+
+export type BuildTarget = {
+  readonly output: LogicalOutputId;
+};
+
+export type Satisfaction = {
+  readonly output: LogicalOutputId;
+  readonly candidate: CandidateId;
+};
+
+export type BuildRequest = {
+  readonly format: "hypit.build-request@1";
+  readonly targets: readonly BuildTarget[];
+};
+
+export type BuildOutputBinding = {
+  readonly output: LogicalOutputId;
+  readonly record: RecordId;
+  readonly type: TypeRef;
+};
+
+export type ProducerStep = {
+  readonly id: StepId;
+  readonly producer: ProducerRef;
+  readonly inputs: Readonly<Record<string, RecordId>>;
+  readonly outputs: Readonly<Record<string, RecordId>>;
+  readonly needs: Readonly<Record<string, NeedBinding>>;
+};
+
+export type BuildGoal = {
+  readonly record: RecordId;
+  readonly type: TypeRef;
+};
+
+export type BuildPlan = {
+  readonly format: "hypit.plan@1";
+  readonly steps: readonly ProducerStep[];
+  readonly goals: readonly BuildGoal[];
+  /** Every Logical Output reached by the selected execution, independent of how it was supplied. */
+  readonly outputBindings: readonly BuildOutputBinding[];
+};
+
+/** The complete execution intent compiled from one `.svrun` source. */
+export type RunGraph = {
+  readonly format: "hypit.run-graph@1";
+  /** Literal values authored by this Run and reached only through its selected Fragments. */
+  readonly records: readonly TypedRecord[];
+  readonly candidates: readonly Candidate[];
+  readonly operations: readonly OperationNode[];
+  readonly satisfactions: readonly Satisfaction[];
+  readonly targets: readonly BuildTarget[];
+};
+
+export type LinkedProgram = {
+  readonly closure: ResolvedModuleClosure;
+  readonly records: readonly TypedRecord[];
+};
+
+export type StepState = {
+  readonly id: StepId;
+  readonly status: "pending" | "complete";
+};
+
+export type InvokeProducerCommand = {
+  readonly kind: "invoke-producer";
+  readonly id: CommandId;
+  readonly step: StepId;
+  readonly producer: ProducerRef;
+  readonly inputs: Readonly<Record<string, RecordId>>;
+};
+
+export type FulfillNeedCommand = {
+  readonly kind: "fulfill-need";
+  readonly id: CommandId;
+  readonly need: Need;
+};
+
+export type CoreCommand = InvokeProducerCommand | FulfillNeedCommand;
+
+export type ProducerCompletedEvent = {
+  readonly kind: "producer-completed";
+  readonly command: CommandId;
+  readonly outputs: Readonly<Record<string, StoredValue>>;
+  readonly needs: Readonly<Record<string, CanonicalValue>>;
+};
+
+export type NeedFulfilledEvent = {
+  readonly kind: "need-fulfilled";
+  readonly command: CommandId;
+  readonly value: StoredValue;
+};
+
+export type CommandFailedEvent = {
+  readonly kind: "command-failed";
+  readonly command: CommandId;
+  readonly code: string;
+  readonly message: string;
+};
+
+/** One execution result offered to Core. */
+export type CommandResult = ProducerCompletedEvent | NeedFulfilledEvent | CommandFailedEvent;
+
+export type BuildDiagnostic = {
+  readonly code: string;
+  readonly message: string;
+  readonly subject?: string;
+};
+
+/** Immutable finite program selected by one Author Graph plus one Run Graph. */
+export type BuildDefinition = {
+  readonly format: "hypit.build-definition@1";
+  readonly program: LinkedProgram;
+  /** Selected zero-input values. Candidate identity has already served its planning purpose. */
+  readonly initialRecords: readonly TypedRecord[];
+  readonly plan: BuildPlan;
+  readonly targets: readonly BuildTarget[];
+};
+
+type BuildFactBase = {
+  readonly format: "hypit.build-fact@1";
+  readonly command: CommandId;
+};
+
+/** One Producer result admitted by Core. Every added value is stored exactly once. */
+export type ProducerAppliedFact = BuildFactBase & {
+  readonly kind: "producer-applied";
+  readonly step: StepId;
+  readonly records: readonly TypedRecord[];
+  readonly needs: readonly Need[];
+};
+
+/** One external Need result admitted by Core. */
+export type NeedAppliedFact = BuildFactBase & {
+  readonly kind: "need-applied";
+  readonly need: NeedId;
+  readonly record: TypedRecord;
+};
+
+/** One terminal command failure admitted by Core. */
+export type CommandFailedFact = BuildFactBase & {
+  readonly kind: "command-failed";
+  readonly diagnostic: BuildDiagnostic;
+};
+
+/** Fixed Core facts, not an extensible event or patch system. */
+export type BuildFact = ProducerAppliedFact | NeedAppliedFact | CommandFailedFact;
+
+/** Materialized read/execution view. Durable Stores persist Definition + Facts, never this object. */
+export type BuildState = {
+  readonly format: "hypit.build@1";
+  readonly program: LinkedProgram;
+  readonly plan: BuildPlan;
+  readonly targets: readonly BuildTarget[];
+  readonly status: "active" | "complete" | "failed";
+  readonly records: readonly TypedRecord[];
+  readonly steps: readonly StepState[];
+  readonly needs: readonly Need[];
+  readonly outstanding: readonly CoreCommand[];
+  readonly diagnostics: readonly BuildDiagnostic[];
+};

package/packages/protocol/src/canonical.ts

@@ -0,0 +1,37 @@
+import { SvmlError } from "./error.js";
+import type { ResourceId } from "./identity.js";
+import type { CanonicalValue } from "./value.js";
+
+function normalize(value: unknown, path: string): CanonicalValue {
+  if (value === null || typeof value === "boolean" || typeof value === "string") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new SvmlError("NON_CANONICAL_NUMBER", `${path} must be finite`);
+    return Object.is(value, -0) ? 0 : value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item, index) => normalize(item, `${path}[${index}]`));
+  }
+  if (typeof value === "object") {
+    const result: Record<string, CanonicalValue> = {};
+    for (const [key, item] of Object.entries(value).sort(([left], [right]) => left.localeCompare(right))) {
+      if (item === undefined) {
+        throw new SvmlError("NON_CANONICAL_UNDEFINED", `${path}.${key} is undefined`);
+      }
+      result[key] = normalize(item, `${path}.${key}`);
+    }
+    return result;
+  }
+  throw new SvmlError("NON_CANONICAL_VALUE", `${path} contains ${typeof value}`);
+}
+
+export function canonicalize(value: unknown): CanonicalValue {
+  return normalize(value, "$input");
+}
+
+export function canonicalStringify(value: unknown): string {
+  return JSON.stringify(canonicalize(value));
+}
+
+export function isResourceId(value: string): value is ResourceId {
+  return /^res_[a-zA-Z0-9._:-]+$/u.test(value);
+}

package/packages/protocol/src/error.ts

@@ -0,0 +1,11 @@
+export class SvmlError extends Error {
+  readonly code: string;
+  readonly subject: string | undefined;
+
+  constructor(code: string, message: string, subject?: string) {
+    super(message);
+    this.name = "SvmlError";
+    this.code = code;
+    this.subject = subject;
+  }
+}

package/packages/protocol/src/identity.ts

@@ -0,0 +1,59 @@
+/** Opaque identity for one admitted byte resource. Equal bytes may have different identities. */
+export type ResourceId = `res_${string}`;
+
+export type RecordId = string;
+export type LogicalOutputId = string;
+export type CandidateId = string;
+export type OperationId = string;
+export type NeedId = string;
+export type StepId = string;
+export type CommandId = string;
+
+export type ModuleRef = {
+  readonly name: string;
+  readonly version: string;
+};
+
+/**
+ * A Type is its owning Module and its name, and nothing else is compared. Two Types whose values
+ * carry identical shapes are distinct, so one is refused where the other is declared — there is no
+ * structural fallback to fall back to.
+ */
+export type TypeRef = {
+  readonly module: ModuleRef;
+  readonly name: string;
+};
+
+export type ProducerRef = {
+  readonly module: ModuleRef;
+  readonly name: string;
+};
+
+export type CapabilityRef = {
+  readonly module: ModuleRef;
+  readonly name: string;
+};
+
+export function moduleKey(ref: ModuleRef): string {
+  return `${ref.name}@${ref.version}`;
+}
+
+export function typeKey(ref: TypeRef): string {
+  return `${moduleKey(ref.module)}#${ref.name}`;
+}
+
+export function producerKey(ref: ProducerRef): string {
+  return `${moduleKey(ref.module)}#${ref.name}`;
+}
+
+export function capabilityKey(ref: CapabilityRef): string {
+  return `${moduleKey(ref.module)}#${ref.name}`;
+}
+
+export function sameModule(left: ModuleRef, right: ModuleRef): boolean {
+  return left.name === right.name && left.version === right.version;
+}
+
+export function sameType(left: TypeRef, right: TypeRef): boolean {
+  return sameModule(left.module, right.module) && left.name === right.name;
+}

package/packages/protocol/src/index.ts

@@ -0,0 +1,9 @@
+export * from "./canonical.js";
+export * from "./build-id.js";
+export * from "./error.js";
+export { modulePackageAbi } from "./module.js";
+export { blobRefObjectSchema } from "./value.js";
+export type * from "./build.js";
+export * from "./identity.js";
+export type * from "./module.js";
+export type * from "./value.js";