@hypit/hypit 0.0.1 → 0.1.1

package/packages/comment-sticker/src/surface.ts

@@ -0,0 +1,172 @@
+import { createTemporalSpace, resolveTemporalContext } from "@hypit/temporal-markup";
+import { artifactTypes } from "@hypit/artifact";
+import { mediaTypes } from "@hypit/media";
+import type { FontStackRef } from "@hypit/media";
+import { spatialTypes } from "@hypit/spatial";
+import { svsRecipeType } from "@hypit/svs";
+import type { SvsRecipe } from "@hypit/svs";
+import { sealText, textTypes } from "@hypit/text";
+import type {
+  StructuredElement,
+  StructuredSurfaceHandler,
+  SurfaceComponentDraft,
+  SurfaceRecordDraft,
+  SurfaceResolvedReference,
+  MarkupAttributeValue,
+} from "@hypit/markup";
+import { createTemporalWindowProjection, temporalWindowAttributeNames } from "@hypit/temporal-markup";
+
+import { decodeCommentStickerStyle } from "./author.js";
+import { createCommentStickerFragment } from "./fragment.js";
+import { commentStickerTypes } from "./manifest.js";
+import { sealCommentStickerHeader, sealCommentStickerItemSpec } from "./program.js";
+
+const TIMING = temporalWindowAttributeNames;
+
+function localName(name: string): string { return name.slice(name.lastIndexOf(":") + 1); }
+function sameType(left: SurfaceResolvedReference["type"], right: SurfaceResolvedReference["type"]): boolean {
+  return left.module.name === right.module.name && left.module.version === right.module.version && left.name === right.name;
+}
+function allowed(element: StructuredElement, names: readonly string[], required: readonly string[] = []): void {
+  const unknown = Object.keys(element.attributes).filter((name) => !names.includes(name));
+  if (unknown.length > 0) throw new Error(`${element.name} does not accept ${unknown[0]}.`);
+  const missing = required.filter((name) => element.attributes[name] === undefined);
+  if (missing.length > 0) throw new Error(`${element.name} requires ${missing.join(", ")}.`);
+}
+function text(element: StructuredElement, name: string, fallback?: string): string {
+  const value = element.attributes[name];
+  if (value === undefined && fallback !== undefined) return fallback;
+  if (typeof value !== "string" || !value.trim()) throw new Error(`${element.name}.${name} must be text.`);
+  return value.trim();
+}
+function optionalText(element: StructuredElement, name: string): string | undefined {
+  const value = element.attributes[name];
+  if (value === undefined) return undefined;
+  if (typeof value !== "string" || !value.trim()) throw new Error(`${element.name}.${name} must be text.`);
+  return value.trim();
+}
+function reference(
+  raw: MarkupAttributeValue | undefined,
+  label: string,
+  expected: SurfaceResolvedReference["type"],
+  resolve: (path: string) => SurfaceResolvedReference | undefined,
+): SurfaceResolvedReference {
+  if (typeof raw !== "object" || raw.kind !== "reference") throw new Error(`${label} must be a reference.`);
+  const value = resolve(raw.path);
+  if (value === undefined || !sameType(value.type, expected)) throw new Error(`${label} has the wrong Type.`);
+  return value;
+}
+function inline<T>(value: SurfaceResolvedReference, label: string): T {
+  if (value.record?.value.kind !== "inline") throw new Error(`${label} must reference authored inline data.`);
+  return value.record.value.value as unknown as T;
+}
+function dedent(value: string): string {
+  const lines = value.replace(/^\n/u, "").replace(/\n\s*$/u, "").split("\n");
+  const indentation = lines.filter((line) => line.trim()).reduce(
+    (minimum, line) => Math.min(minimum, /^\s*/u.exec(line)?.[0].length ?? 0), Number.POSITIVE_INFINITY,
+  );
+  return lines.map((line) => line.slice(Number.isFinite(indentation) ? indentation : 0)).join("\n").trim();
+}
+
+function graphText(
+  raw: MarkupAttributeValue | undefined,
+  label: string,
+  resolve: (path: string) => SurfaceResolvedReference | undefined,
+): string | SurfaceResolvedReference {
+  if (typeof raw === "string" && raw.trim().length > 0) return raw.trim();
+  return reference(raw, label, textTypes.text, resolve);
+}
+
+export const decodeCommentStickerStyleSurface: StructuredSurfaceHandler = ({ element, resolveReference }) => {
+  allowed(element, ["id", "recipe", "font"], ["id", "recipe", "font"]);
+  if (element.children.some((child) => child.kind === "element" || child.value.trim())) throw new Error(`${element.name} must be empty.`);
+  const id = text(element, "id");
+  const recipeRef = reference(element.attributes.recipe, `${element.name}.recipe`, svsRecipeType, resolveReference);
+  const fontRef = reference(element.attributes.font, `${element.name}.font`, mediaTypes.fontStack, resolveReference);
+  const style = decodeCommentStickerStyle(inline<SvsRecipe>(recipeRef, `${element.name}.recipe`), inline<FontStackRef>(fontRef, `${element.name}.font`), id);
+  return { records: [{ id, type: commentStickerTypes.style, value: { kind: "inline", value: style }, range: element.range }], components: [], fragments: [] };
+};
+
+export const decodeCommentStickerTrackSurface: StructuredSurfaceHandler = ({ element, resolveReference }) => {
+  allowed(element, ["id", "canvas", "semantic"], ["id", "canvas", "semantic"]);
+  const id = text(element, "id");
+  const canvas = reference(element.attributes.canvas, `${element.name}.canvas`, spatialTypes.canvas, resolveReference);
+  const context = resolveTemporalContext({ element, resolveReference });
+  const time = createTemporalSpace({ id: id, element, ...context });
+  const headerId = `${id}.__header`;
+  const records: SurfaceRecordDraft[] = [{
+    id: headerId,
+    type: commentStickerTypes.header,
+    value: { kind: "inline", value: sealCommentStickerHeader({ id }) },
+    range: element.range,
+  }];
+  const temporalComponents: SurfaceComponentDraft[] = [...time.components];
+  const temporalFragments: ReturnType<typeof createTemporalWindowProjection>["fragments"][number][] = [...time.fragments];
+  const inputs: Record<string, typeof canvas.ref> = { canvas: canvas.ref, header: { kind: "record", id: headerId }, space: time.space.ref };
+  const items: Parameters<typeof createCommentStickerFragment>[0][number][] = [];
+  for (const child of element.children) {
+    if (child.kind === "text") {
+      if (child.value.trim()) throw new Error(`${element.name} accepts only Sticker children.`);
+      continue;
+    }
+    if (localName(child.name) !== "Sticker") throw new Error(`${element.name} accepts only Sticker children.`);
+    if (child.children.some((node) => node.kind === "element")) throw new Error(`${child.name} accepts plain comment text only.`);
+    allowed(child, ["id", "comment", "frame", "style", "avatar", "author", "header", "meta", ...TIMING], ["id", "frame", "style"]);
+    const itemId = text(child, "id");
+    const temporal = createTemporalWindowProjection({ id: itemId, element: child, ...context, space: time.space, resolveReference });
+    records.push(...temporal.records); temporalComponents.push(...temporal.components); temporalFragments.push(...temporal.fragments);
+    const suffix = String(items.length + 1).padStart(4, "0");
+    const frame = reference(child.attributes.frame, `${child.name}.frame`, spatialTypes.frame, resolveReference);
+    const style = reference(child.attributes.style, `${child.name}.style`, commentStickerTypes.style, resolveReference);
+    const avatar = child.attributes.avatar === undefined ? undefined : reference(child.attributes.avatar, `${child.name}.avatar`, artifactTypes.blob, resolveReference);
+    const comment = child.attributes.comment === undefined
+      ? dedent(child.children.map((node) => node.kind === "text" ? node.value : "").join(""))
+      : graphText(child.attributes.comment, `${child.name}.comment`, resolveReference);
+    if (child.attributes.comment !== undefined && child.children.some((node) => node.kind === "element" || node.value.trim())) {
+      throw new Error(`${child.name} cannot combine comment with body text.`);
+    }
+    if (typeof comment === "string" && !comment) throw new Error(`${child.name} requires comment text.`);
+    const author = child.attributes.author === undefined ? undefined : graphText(child.attributes.author, `${child.name}.author`, resolveReference);
+    const displayHeader = child.attributes.header === undefined ? undefined : graphText(child.attributes.header, `${child.name}.header`, resolveReference);
+    const meta = child.attributes.meta === undefined ? undefined : graphText(child.attributes.meta, `${child.name}.meta`, resolveReference);
+    const specId = `${id}.item.${suffix}.spec`;
+    records.push({
+      id: specId,
+      type: commentStickerTypes.itemSpec,
+      value: { kind: "inline", value: sealCommentStickerItemSpec({
+
+        id: itemId,
+      }) },
+      range: child.range,
+    });
+    const windowName = `item-${suffix}-window`;
+    const specName = `item-${suffix}-spec`; const frameName = `item-${suffix}-frame`; const styleName = `item-${suffix}-style`;
+    inputs[specName] = { kind: "record", id: specId }; inputs[windowName] = temporal.ref;
+    inputs[frameName] = frame.ref; inputs[styleName] = style.ref;
+    const attachText = (field: string, value: string | SurfaceResolvedReference): string => {
+      const name = `item-${suffix}-${field}`;
+      if (typeof value === "string") {
+        const recordId = `${id}.item.${suffix}.${field}`;
+        records.push({ id: recordId, type: textTypes.text, value: { kind: "inline", value: sealText(value) }, range: child.range });
+        inputs[name] = { kind: "record", id: recordId };
+      } else inputs[name] = value.ref;
+      return name;
+    };
+    const commentName = attachText("comment", comment);
+    const authorName = author === undefined ? undefined : attachText("author", author);
+    const headerTextName = displayHeader === undefined ? undefined : attachText("header", displayHeader);
+    const metaName = meta === undefined ? undefined : attachText("meta", meta);
+    const avatarName = avatar === undefined ? undefined : `item-${suffix}-avatar`;
+    if (avatar !== undefined) inputs[avatarName!] = avatar.ref;
+    const copy = { commentName, ...(authorName === undefined ? {} : { authorName }), ...(headerTextName === undefined ? {} : { headerTextName }), ...(metaName === undefined ? {} : { metaName }) };
+    items.push({ windowName, specName, frameName, styleName, ...copy, ...(avatarName === undefined ? {} : { avatarName }) });
+  }
+  if (items.length === 0) throw new Error(`${element.name} requires at least one Sticker.`);
+  const fragment = createCommentStickerFragment(items);
+  return {
+    records,
+    components: [...temporalComponents, { id, fragment: fragment.id, inputs, outputs: { program: `${id}.program`, track: `${id}.track` }, range: element.range }],
+    fragments: [...temporalFragments, fragment],
+    exports: [`${id}.program`, `${id}.track`],
+  };
+};

package/packages/comment-sticker/src/types.ts

@@ -0,0 +1,109 @@
+import type { FrameSpan } from "@hypit/composition";
+import type { FontArtifactRef } from "@hypit/media";
+import type { BlobRef } from "@hypit/protocol";
+import type { SpatialFrame } from "@hypit/spatial";
+
+export type CommentStickerTextStyle = {
+  readonly fonts: readonly FontArtifactRef[];
+  readonly sizePx: number;
+  readonly weight: number;
+  readonly lineHeight: number;
+  readonly color: string;
+};
+
+export type CommentStickerStyle = {
+  readonly id: string;
+  readonly stackingOrder: number;
+  readonly card: {
+    readonly background: string;
+    readonly borderColor: string;
+    readonly borderWidthPx: number;
+    readonly radiusPx: number;
+    readonly paddingXPx: number;
+    readonly paddingYPx: number;
+    readonly gapPx: number;
+    readonly rotationDeg: number;
+    readonly shadow: {
+      readonly color: string;
+      readonly offsetX: number;
+      readonly offsetY: number;
+      readonly blurPx: number;
+      readonly spreadPx: number;
+    };
+    readonly tail: {
+      readonly enabled: boolean;
+      readonly widthPx: number;
+      readonly heightPx: number;
+      readonly offsetXPx: number;
+    };
+  };
+  readonly avatar: {
+    readonly fallback: "none" | "initial";
+    readonly sizePx: number;
+    readonly borderWidthPx: number;
+    readonly borderColor: string;
+    readonly background: string;
+    readonly textColor: string;
+  };
+  readonly header: CommentStickerTextStyle;
+  readonly body: CommentStickerTextStyle & { readonly maxLines: number };
+  readonly meta: CommentStickerTextStyle;
+  readonly motion: {
+    readonly enter: {
+      readonly kind: "none" | "fade" | "pop" | "slide-pop";
+      readonly durationFrames: number;
+      readonly offsetYPx: number;
+      readonly startScale: number;
+      readonly rotationDeltaDeg: number;
+      readonly easing: "linear" | "ease-in" | "ease-out" | "ease-in-out" | "out-back";
+    };
+    readonly exit: {
+      readonly kind: "none" | "fade" | "fade-up";
+      readonly durationFrames: number;
+      readonly offsetYPx: number;
+      readonly easing: "linear" | "ease-in" | "ease-out" | "ease-in-out";
+    };
+    readonly hold: {
+      readonly kind: "none" | "float";
+      readonly amplitudeYPx: number;
+      readonly rotationAmplitudeDeg: number;
+      readonly periodFrames: number;
+    };
+  };
+};
+
+export type CommentStickerContent = {
+  readonly comment: string;
+  readonly author?: string;
+  readonly header?: string;
+  readonly meta?: string;
+};
+
+export type CommentStickerItemSpec = {
+  readonly id: string;
+};
+
+export type CommentStickerHeader = {
+  readonly id: string;
+};
+
+export type CommentStickerItemProgram = {
+  readonly id: string;
+  /** Author-owned Item realized by this externally projected window. */
+  readonly subjectId: string;
+  readonly span: FrameSpan;
+  readonly frame: SpatialFrame;
+  readonly style: CommentStickerStyle;
+  readonly content: CommentStickerContent;
+  readonly avatar?: BlobRef;
+  readonly tieBreak: string;
+};
+
+export type CommentStickerSet = {
+  readonly items: readonly CommentStickerItemProgram[];
+};
+
+export type CommentStickerProgram = {
+  readonly id: string;
+  readonly items: readonly CommentStickerItemProgram[];
+};

package/packages/comment-sticker-studio/README.md

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

package/packages/comment-sticker-studio/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@hypit/comment-sticker-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/comment-sticker": "workspace:*",
+    "@hypit/composition": "workspace:*",
+    "@hypit/studio-adapter": "workspace:*"
+  }
+}

package/packages/comment-sticker-studio/src/activation.ts

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

package/packages/comment-sticker-studio/src/index.ts

@@ -0,0 +1,132 @@
+import { commentStickerMarkupSurfaces, commentStickerModuleRef, commentStickerTypes } from "@hypit/comment-sticker";
+import type { CommentStickerProgram } from "@hypit/comment-sticker";
+import { compositionTypes } from "@hypit/composition";
+import type { StudioTrackCompanion, StudioTrackCompanionContext, StudioEntityDraft, StudioInspectorFieldDeclaration, StudioSourceBindingDeclaration } from "@hypit/studio-adapter";
+import { artifactPreview, childEntities, previewLayer, requiredSurfaceValue, temporalLineageFor, temporalSemanticSource, textLayer } from "@hypit/studio-adapter";
+
+const frameParameters: readonly StudioSourceBindingDeclaration[] = [
+  { name: "within" },
+  ...["left", "top", "right", "bottom", "x", "y", "width", "height"].map((name) => ({ name, writable: true })),
+];
+
+const commentProperties = (commentStickerMarkupSurfaces
+  .find((surface) => surface.name === "style")?.vocabulary.attributes
+  .find((attribute) => attribute.name === "recipe")?.recipe ?? []);
+
+function title(name: string): string {
+  return name.split("-").map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`).join(" ");
+}
+
+function valuesFor(property: typeof commentProperties[number]): readonly string[] | undefined {
+  return "values" in property ? property.values : undefined;
+}
+
+type CommentPlacement = Pick<StudioInspectorFieldDeclaration, "domain" | "page" | "section">;
+
+function commentPlace(domain: "where" | "how" | "when", page: string, section: string): CommentPlacement {
+  const id = section.toLowerCase().replaceAll(" ", "-");
+  return { domain, page: { id: page.toLowerCase(), label: page }, section: { id, label: section } };
+}
+
+const commentPlacement = new Map<string, CommentPlacement>();
+function placeComment(names: readonly string[], domain: "where" | "how" | "when", page: string, section: string): void {
+  for (const name of names) commentPlacement.set(name, commentPlace(domain, page, section));
+}
+
+placeComment(["stack-order"], "where", "Layout", "Stacking");
+placeComment(["padding-x", "padding-y", "gap", "radius"], "where", "Layout", "Card");
+placeComment(["tail-width", "tail-height", "tail-offset-x"], "where", "Layout", "Tail");
+placeComment(["avatar-size", "avatar-border-width"], "where", "Layout", "Avatar");
+placeComment([
+  "header-size", "header-line-height", "body-size", "body-line-height", "body-max-lines", "meta-size", "meta-line-height",
+], "where", "Layout", "Copy");
+placeComment([
+  "background", "border-color", "border-width", "rotation", "shadow-color", "shadow-x", "shadow-y", "shadow-blur",
+  "shadow-spread", "tail", "avatar-fallback", "avatar-border-color", "avatar-background", "avatar-text-color",
+], "how", "Appearance", "Card");
+placeComment(["header-weight", "header-color", "body-weight", "body-color", "meta-weight", "meta-color"], "how", "Appearance", "Copy");
+placeComment([
+  "enter", "enter-frames", "enter-offset-y", "enter-start-scale", "enter-rotation-delta", "enter-easing",
+], "when", "Motion", "Enter");
+placeComment(["exit", "exit-frames", "exit-offset-y", "exit-easing"], "when", "Motion", "Exit");
+placeComment(["hold", "hold-amplitude-y", "hold-rotation-amplitude", "hold-period-frames"], "when", "Motion", "Hold");
+
+const commentColorProperties = new Set([
+  "background", "border-color", "shadow-color", "avatar-border-color", "avatar-background", "avatar-text-color",
+  "header-color", "body-color", "meta-color",
+]);
+
+const commentInspector: readonly StudioInspectorFieldDeclaration[] = commentProperties.map((property) => {
+  const placement = commentPlacement.get(property.name);
+  if (placement === undefined) throw new Error(`Comment Sticker Studio has no explicit Inspector declaration for ${property.name}.`);
+  const options = valuesFor(property);
+  return {
+    binding: `style.${property.name}`, label: title(property.name), ...placement,
+    ...(property.summary === undefined ? {} : { summary: property.summary }),
+    control: options !== undefined ? "select" : commentColorProperties.has(property.name) ? "color" : "number",
+    ...(options === undefined ? {} : { options }),
+  };
+});
+
+function projectComments(context: StudioTrackCompanionContext): readonly StudioEntityDraft[] {
+  const program = requiredSurfaceValue(context, "program") as CommentStickerProgram;
+  const items = program.items.map((item) => ({
+    id: item.id,
+    subjectId: item.subjectId,
+    startFrame: item.span.startFrame,
+    endFrameExclusive: item.span.endFrameExclusive,
+    stackOrder: item.style.stackingOrder,
+    sourceTypes: [commentStickerTypes.itemSpec],
+  }));
+  return childEntities(context, items, "comment-sticker", "standard").map((entity, index) => {
+    const item = program.items[index];
+    if (item === undefined) return entity;
+    const temporal = temporalLineageFor(context, item.id, "window");
+    const semanticSource = temporalSemanticSource(temporal);
+    return {
+      ...entity,
+      display: {
+        title: entity.display.title,
+        layers: [
+          ...(item.avatar === undefined ? [] : [previewLayer(artifactPreview("image", item.avatar.resource), "contain", "decoration")]),
+          textLayer(item.content.comment),
+        ],
+      },
+      ...(semanticSource?.id === undefined
+        ? {}
+        : { markerId: semanticSource.id }),
+      ...(temporal === undefined ? {} : { temporal }),
+    };
+  });
+}
+
+export const commentStickerStudioTrackCompanions: readonly StudioTrackCompanion[] = [
+  {
+    id: "track", role: "track",
+    output: { type: compositionTypes.visualTrack, surface: "track", modules: [commentStickerModuleRef] },
+    family: "comment-sticker", tone: "orange", icon: "component",
+    bindings: [
+      { name: "frame", referenced: frameParameters },
+      {
+        name: "style",
+        recipe: { through: ["recipe"], bindings: commentProperties.map(({ name }) => ({ name })) },
+      },
+      ...["comment", "author", "header", "meta"].map((name) => ({ name, writable: true })),
+      { name: "avatar" },
+    ],
+    inspector: [
+      ...frameParameters.filter(({ writable }) => writable === true).map(({ name }) => ({
+        binding: `frame.${name}`, label: title(name), domain: "where" as const,
+        page: { id: "frame", label: "Frame" }, section: { id: "frame", label: "Frame" }, control: "text" as const,
+      })),
+      ...commentInspector,
+      ...["comment", "author", "header", "meta"].map((binding) => ({
+        binding, label: title(binding), domain: "how" as const,
+        page: { id: "copy", label: "Copy" }, section: { id: "copy", label: "Copy" }, control: "text" as const,
+      })),
+    ],
+    requiredValues: ["program"], project: projectComments,
+    poster: { source: "surface-preview" },
+    lane: { heightPx: 52 },
+  },
+];

package/packages/compiler-markup-node/README.md

@@ -0,0 +1,12 @@
+# `@hypit/compiler-markup-node`
+
+Reference Node compiler assembly for the official `@hypit/markup` authoring language.
+
+The package selects the Markup Frontend ABI, installs Markup Surface Host facets from already trusted
+package contributions, and combines them with the syntax-neutral `@hypit/compiler-node`. It does not
+discover packages, grant Runtime authority or know any video component by name.
+
+Every compiled source selects Markup—or another registered Frontend—through its mandatory Source
+Header. Use `@hypit/compiler-node` directly for another Frontend assembly. Use
+`@hypit/package-loader-node` independently when a Runtime only needs locked deterministic compute
+facets and no author syntax.

package/packages/compiler-markup-node/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@hypit/compiler-markup-node",
+  "version": "0.0.0-dev",
+  "license": "SEE LICENSE IN LICENSE",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "@hypit/compiler-node": "workspace:*",
+    "@hypit/component-kit": "workspace:*",
+    "@hypit/elaborator": "workspace:*",
+    "@hypit/workspace": "workspace:*",
+    "@hypit/package-loader-node": "workspace:*",
+    "@hypit/markup": "workspace:*",
+    "@hypit/validation": "workspace:*"
+  },
+  "devDependencies": {
+    "@hypit/workspace-fs-node": "workspace:*"
+  }
+}

package/packages/compiler-markup-node/src/index.ts

@@ -0,0 +1,59 @@
+import { registerTypeValidatorFacets } from "@hypit/component-kit";
+import {
+  ModulePackageRegistry,
+  NodeCompiler,
+} from "@hypit/compiler-node";
+import { AuthorFrontendRegistry, installAuthorFrontendHostFacets } from "@hypit/elaborator";
+import type { Workspace } from "@hypit/workspace";
+import {
+  collectNodePackageComponents,
+} from "@hypit/package-loader-node";
+import type { NodePackageContribution } from "@hypit/package-loader-node";
+import {
+  createMarkupAuthorFrontend,
+  installMarkupSurfaceHostFacets,
+  MarkupSurfaceRegistry,
+} from "@hypit/markup";
+import { TypeValidatorRegistry } from "@hypit/validation";
+
+export type CreateMarkupNodeCompilerOptions = {
+  readonly workspace: Workspace;
+};
+
+/** Assemble the official Markup authoring environment from already trusted package facets. */
+export function createMarkupNodeCompiler(
+  packages: readonly NodePackageContribution[],
+  options: CreateMarkupNodeCompilerOptions,
+): NodeCompiler {
+  const modules = new ModulePackageRegistry();
+  const surfaces = new MarkupSurfaceRegistry();
+  const frontends = new AuthorFrontendRegistry();
+  const validators = new TypeValidatorRegistry();
+  const components = collectNodePackageComponents(packages);
+
+  for (const item of packages) {
+    for (const module of item.modules ?? []) modules.register(module);
+    installMarkupSurfaceHostFacets(item.hostFacets ?? [], surfaces);
+    installAuthorFrontendHostFacets(item.hostFacets ?? [], frontends);
+  }
+
+  for (const component of components) {
+    registerTypeValidatorFacets(validators, component.validators ?? []);
+  }
+
+  frontends.register(createMarkupAuthorFrontend({
+    registry: surfaces,
+    resolveModule(request) {
+      const resolved = modules.resolve(request.from);
+      if (resolved === undefined) throw new Error(`No selected author package satisfies ${request.from}`);
+      return resolved;
+    },
+  }));
+
+  return new NodeCompiler({
+    modules,
+    frontends,
+    validators,
+    workspace: options.workspace,
+  });
+}

package/packages/compiler-node/README.md

@@ -0,0 +1,60 @@
+# `@hypit/compiler-node`
+
+Domain-neutral Node.js compiler host.
+
+This package is outside Core. It connects a replaceable definition-time `Workspace` to the already
+implemented compiler IR:
+
+```text
+Source Header + registered Frontends + registered manifests
+  -> discovered Source/Module closure
+  -> typed Source Closure
+  -> Author Module + Graph
+```
+
+Every Author Source selects its own exact Frontend through the mandatory `@hypit/source` Header.
+The compiler has no suffix table and no entry-Frontend default. A recursively imported source may
+select another Frontend without the importer choosing on its behalf.
+
+`ModulePackageRegistry` maps author import spellings to exact, already trusted manifests and closes
+their declared Resource dependencies. It does not install npm packages or execute module code. An
+embedding application must register the manifests and matching Frontend/Surface implementations it
+has chosen to trust.
+
+`NodeCompiler` requires the host-neutral `Workspace` contract. The reference CLI explicitly selects
+`@hypit/workspace-fs-node`, where every recursive Source import is confined to the canonical root
+that owns the importing SourceUnit, symlink escapes are rejected and each edge is locked to the
+first bytes read for that compilation. The Host may explicitly mount another Source root; the
+Compiler sees only the resulting Workspace units and does not know whether that root came from an
+installed data package, Git, memory or another source. Another Host can supply a different
+Workspace without changing Frontends, Surfaces, Source Closure identity or Core.
+
+The Workspace session owns a separate Source Asset capability. A Frontend/Surface may request an
+asset and assign its exact media type, but it never receives a path, filesystem handle or ambient
+read authority. The Workspace returns a `BlobRef`, the compiler binds that reference into the
+requesting SourceUnit, and the session exposes defensive generic `ArtifactAttachment`s on the Node
+compilation result. `check` and `plan` perform no ResourceStore write. `build` passes the attachments
+to the selected Runtime for size-checked staging.
+
+SourceUnit recursion and Source Asset resolution are intentionally different capabilities: an
+asset cannot import syntax, and a source import does not silently make arbitrary neighboring bytes
+available to package code.
+
+`NodeCompiler` runs a discovery pass first because Headers and imports must be known before source decoding,
+while the exact Module Closure must be known before typed Records can be verified. It then invokes
+the ordinary Elaborator Source Closure implementation.
+
+`NodeRunCompiler` is the separate dual-graph assembly. It compiles one self-described Run Source,
+opens its explicitly named Author Source in the same Workspace session, resolves the complete Run
+Graph, extends the execution Program Closure with Modules referenced only by selected Run
+Fragments, binds Author and Run graph identities into the final immutable graph, and only then asks
+Core for a finite BuildPlan. The Author Graph remains unchanged. There is no Author-only planning
+shortcut.
+
+The package contains no Script, video, Provider, queue, credentials or rendering knowledge. A
+non-video application can use it with only its own manifests, Frontends, Surfaces and chosen
+Workspace implementation.
+
+Package installation, third-party code loading and sandbox execution remain Host
+features above this registry; treating an import string as permission to execute npm code would
+violate the trust boundary.

package/packages/compiler-node/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@hypit/compiler-node",
+  "version": "0.0.0-dev",
+  "license": "SEE LICENSE IN LICENSE",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "@hypit/core": "workspace:*",
+    "@hypit/elaborator": "workspace:*",
+    "@hypit/workspace": "workspace:*",
+    "@hypit/protocol": "workspace:*",
+    "@hypit/run": "workspace:*",
+    "@hypit/source": "workspace:*",
+    "@hypit/text": "workspace:*",
+    "@hypit/validation": "workspace:*"
+  },
+  "devDependencies": {
+    "@hypit/run-markup": "workspace:*",
+    "@hypit/markup": "workspace:*",
+    "@hypit/workspace-fs-node": "workspace:*"
+  }
+}