@aura3d/editor-runtime 1.3.3 → 1.4.1

package/src/ProjectSerializer.ts

@@ -1,200 +0,0 @@
-import { TimelineModel, type TimelineModelConfig } from "./TimelineModel";
-import type { TimelineRuntimeBindingConfig } from "./TimelineRuntimeBridge";
-
-export interface EditorProjectAssetDocument {
-  readonly id: string;
-  readonly name: string;
-  readonly uri?: string;
-  readonly type?: "gltf" | "glb" | "image" | "audio" | "material" | "unknown";
-  readonly source?: string;
-  readonly license?: string;
-  readonly clips?: readonly string[];
-  readonly morphTargets?: readonly string[];
-  readonly diagnostics?: readonly string[];
-}
-
-export interface EditorProjectTimelineDocument extends TimelineModelConfig {
-  readonly bindings?: readonly TimelineRuntimeBindingConfig[];
-  readonly evidence?: {
-    readonly authoredInEditor?: boolean;
-    readonly runtimeReplay?: boolean;
-    readonly animationEvents?: boolean;
-  };
-}
-
-export interface EditorProjectVisualGraphDocument {
-  readonly id: string;
-  readonly name: string;
-  readonly nodes: readonly unknown[];
-  readonly edges: readonly unknown[];
-  readonly runtimeBindings?: readonly {
-    readonly nodeId: string;
-    readonly targetId: string;
-    readonly event?: string;
-  }[];
-}
-
-export interface EditorProjectStateDocument {
-  readonly selectedNodeId?: string | number | null;
-  readonly activeTool?: string;
-  readonly activeTimelineId?: string | null;
-  readonly playMode?: "edit" | "play" | "paused";
-}
-
-export interface EditorProjectDocument {
-  readonly schema: "a3d-editor-project";
-  readonly version?: number;
-  readonly name: string;
-  readonly nodes: readonly unknown[];
-  readonly assets?: readonly (string | EditorProjectAssetDocument)[];
-  readonly timelines?: readonly EditorProjectTimelineDocument[];
-  readonly visualGraphs?: readonly EditorProjectVisualGraphDocument[];
-  readonly editor?: EditorProjectStateDocument;
-  readonly evidence?: {
-    readonly serializedBy?: "editor-runtime" | "editor-app" | string;
-    readonly roundTripReady?: boolean;
-    readonly browserWorkflowReady?: boolean;
-  };
-}
-
-export interface EditorProjectEvidence {
-  readonly kind: "aura-editor-project-evidence";
-  readonly schema: EditorProjectDocument["schema"];
-  readonly version: number | null;
-  readonly name: string;
-  readonly nodeCount: number;
-  readonly assetCount: number;
-  readonly timelineCount: number;
-  readonly visualGraphCount: number;
-  readonly timelineBindingCount: number;
-  readonly signalMarkerCount: number;
-  readonly typedAssetEvidenceCount: number;
-  readonly hasAnimationTimeline: boolean;
-  readonly hasRuntimeReplayBindings: boolean;
-  readonly hasVisualGraphBindings: boolean;
-  readonly roundTripReady: boolean;
-  readonly evidence: {
-    readonly projectSerialization: true;
-    readonly timelineSerialization: boolean;
-    readonly visualGraphSerialization: boolean;
-    readonly runtimeReplayBindings: boolean;
-    readonly sourceLicenseAssetEvidence: boolean;
-  };
-}
-
-export function serializeEditorProject(project: EditorProjectDocument): string {
-  const normalized = validateEditorProject(project);
-  return `${JSON.stringify(normalized, null, 2)}\n`;
-}
-
-export function parseEditorProject(text: string): EditorProjectDocument {
-  const parsed = JSON.parse(text) as EditorProjectDocument;
-  return validateEditorProject(parsed);
-}
-
-export function validateEditorProject(project: EditorProjectDocument): EditorProjectDocument {
-  if (!isRecord(project)) throw new Error("Editor project document must be an object.");
-  if (project.schema !== "a3d-editor-project") throw new Error("Unsupported editor project schema.");
-  if (typeof project.name !== "string" || !project.name.trim()) throw new Error("Editor project name is required.");
-  if (!Array.isArray(project.nodes)) throw new Error("Editor project nodes must be an array.");
-  validateAssets(project.assets ?? []);
-  validateTimelines(project.timelines ?? []);
-  validateVisualGraphs(project.visualGraphs ?? []);
-  return project;
-}
-
-export function collectEditorProjectEvidence(project: EditorProjectDocument): EditorProjectEvidence {
-  const parsed = validateEditorProject(project);
-  const timelines = parsed.timelines ?? [];
-  const visualGraphs = parsed.visualGraphs ?? [];
-  const timelineBindingCount = timelines.reduce((total, timeline) => total + (timeline.bindings?.length ?? 0), 0);
-  const signalMarkerCount = timelines.reduce((total, timeline) => {
-    return total + (timeline.tracks ?? []).reduce((trackTotal, track) => {
-      if (track.type !== "signal") return trackTotal;
-      return trackTotal + (track.clips?.length ?? 0);
-    }, 0);
-  }, 0);
-  const typedAssetEvidenceCount = (parsed.assets ?? []).filter((asset) => {
-    return typeof asset !== "string" && Boolean(asset.id && asset.name && asset.source && asset.license);
-  }).length;
-  const assetCount = parsed.assets?.length ?? 0;
-  const hasAnimationTimeline = timelines.some((timeline) => (timeline.tracks ?? []).some((track) => track.type === "animation"));
-  const hasVisualGraphBindings = visualGraphs.some((graph) => (graph.runtimeBindings?.length ?? 0) > 0);
-  const hasRuntimeReplayBindings = timelineBindingCount > 0;
-  return {
-    kind: "aura-editor-project-evidence",
-    schema: parsed.schema,
-    version: parsed.version ?? null,
-    name: parsed.name,
-    nodeCount: parsed.nodes.length,
-    assetCount,
-    timelineCount: timelines.length,
-    visualGraphCount: visualGraphs.length,
-    timelineBindingCount,
-    signalMarkerCount,
-    typedAssetEvidenceCount,
-    hasAnimationTimeline,
-    hasRuntimeReplayBindings,
-    hasVisualGraphBindings,
-    roundTripReady: parsed.nodes.length > 0 && timelines.length > 0 && hasRuntimeReplayBindings,
-    evidence: {
-      projectSerialization: true,
-      timelineSerialization: timelines.length > 0,
-      visualGraphSerialization: visualGraphs.length > 0,
-      runtimeReplayBindings: hasRuntimeReplayBindings || hasVisualGraphBindings,
-      sourceLicenseAssetEvidence: assetCount > 0 && typedAssetEvidenceCount === assetCount
-    }
-  };
-}
-
-function validateAssets(assets: readonly (string | EditorProjectAssetDocument)[]): void {
-  if (!Array.isArray(assets)) throw new Error("Editor project assets must be an array.");
-  for (const asset of assets) {
-    if (typeof asset === "string") {
-      if (!asset.trim()) throw new Error("Editor project asset ids must be non-empty.");
-      continue;
-    }
-    if (!asset.id.trim()) throw new Error("Editor project asset id is required.");
-    if (!asset.name.trim()) throw new Error(`Editor project asset name is required: ${asset.id}`);
-    assertStringArray(asset.clips, `asset clips for ${asset.id}`);
-    assertStringArray(asset.morphTargets, `asset morphTargets for ${asset.id}`);
-    assertStringArray(asset.diagnostics, `asset diagnostics for ${asset.id}`);
-  }
-}
-
-function validateTimelines(timelines: readonly EditorProjectTimelineDocument[]): void {
-  if (!Array.isArray(timelines)) throw new Error("Editor project timelines must be an array.");
-  for (const timeline of timelines) {
-    new TimelineModel(timeline);
-    for (const binding of timeline.bindings ?? []) {
-      if (!binding.targetId.trim()) throw new Error(`Timeline binding targetId is required for timeline ${timeline.id ?? timeline.name ?? "unnamed"}.`);
-      if (binding.trackId !== undefined && !binding.trackId.trim()) throw new Error("Timeline binding trackId cannot be empty.");
-      if (binding.trackName !== undefined && !binding.trackName.trim()) throw new Error("Timeline binding trackName cannot be empty.");
-    }
-  }
-}
-
-function validateVisualGraphs(graphs: readonly EditorProjectVisualGraphDocument[]): void {
-  if (!Array.isArray(graphs)) throw new Error("Editor project visualGraphs must be an array.");
-  for (const graph of graphs) {
-    if (!graph.id.trim()) throw new Error("Editor project visual graph id is required.");
-    if (!graph.name.trim()) throw new Error(`Editor project visual graph name is required: ${graph.id}`);
-    if (!Array.isArray(graph.nodes)) throw new Error(`Editor project visual graph nodes must be an array: ${graph.id}`);
-    if (!Array.isArray(graph.edges)) throw new Error(`Editor project visual graph edges must be an array: ${graph.id}`);
-    for (const binding of graph.runtimeBindings ?? []) {
-      if (!binding.nodeId.trim()) throw new Error(`Visual graph runtime binding nodeId is required: ${graph.id}`);
-      if (!binding.targetId.trim()) throw new Error(`Visual graph runtime binding targetId is required: ${graph.id}`);
-    }
-  }
-}
-
-function assertStringArray(values: readonly string[] | undefined, label: string): void {
-  if (values === undefined) return;
-  if (!Array.isArray(values) || values.some((value) => !value.trim())) {
-    throw new Error(`Editor project ${label} must be non-empty strings.`);
-  }
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}

package/src/PropertyPanel.ts

@@ -1,82 +0,0 @@
-import { CommandHistory } from "./CommandHistory";
-import { InspectorModel, type InspectorEditableValue, type InspectorProperty } from "./InspectorModel";
-
-export interface PropertyPanelField extends InspectorProperty {
-  readonly label: string;
-}
-
-export interface PropertyPanelOptions {
-  readonly history?: CommandHistory;
-  readonly inspector?: InspectorModel;
-  readonly onEdit?: (path: readonly string[], value: InspectorEditableValue) => void;
-}
-
-export class PropertyPanel {
-  readonly history: CommandHistory;
-  readonly inspector: InspectorModel;
-  private disposers: (() => void)[] = [];
-
-  constructor(options: PropertyPanelOptions = {}) {
-    this.history = options.history ?? new CommandHistory();
-    this.inspector = options.inspector ?? new InspectorModel();
-  }
-
-  describe(target: object): readonly PropertyPanelField[] {
-    return this.inspector.describe(target).map((property) => ({
-      ...property,
-      label: property.path.join(".")
-    }));
-  }
-
-  async edit(target: object, path: readonly string[], value: InspectorEditableValue): Promise<void> {
-    await this.history.execute(this.inspector.createSetPropertyCommand(target, path, value));
-  }
-
-  render(target: object | undefined, container: HTMLElement, options: Pick<PropertyPanelOptions, "onEdit"> = {}): readonly PropertyPanelField[] {
-    this.dispose();
-    container.replaceChildren();
-    if (!target) return [];
-    const fields = this.describe(target);
-    const documentRef = container.ownerDocument;
-    for (const field of fields) {
-      const row = documentRef.createElement("label");
-      row.className = "aura-property-panel__row";
-      const name = documentRef.createElement("span");
-      name.className = "aura-property-panel__label";
-      name.textContent = field.label;
-      row.append(name);
-      if (field.editable) {
-        const input = documentRef.createElement("input");
-        input.className = "aura-property-panel__input";
-        input.name = field.label;
-        input.value = String(field.value);
-        input.type = field.type === "number" ? "number" : field.type === "boolean" ? "checkbox" : "text";
-        if (field.type === "boolean") input.checked = Boolean(field.value);
-        const change = (): void => {
-          const value = parseInput(input, field.type);
-          void this.edit(target, field.path, value).then(() => options.onEdit?.(field.path, value));
-        };
-        input.addEventListener("change", change);
-        this.disposers.push(() => input.removeEventListener("change", change));
-        row.append(input);
-      } else {
-        const value = documentRef.createElement("span");
-        value.className = "aura-property-panel__value";
-        value.textContent = field.type;
-        row.append(value);
-      }
-      container.append(row);
-    }
-    return fields;
-  }
-
-  dispose(): void {
-    for (const dispose of this.disposers.splice(0)) dispose();
-  }
-}
-
-function parseInput(input: HTMLInputElement, type: InspectorProperty["type"]): InspectorEditableValue {
-  if (type === "number") return Number(input.value);
-  if (type === "boolean") return input.checked;
-  return input.value;
-}

package/src/RenderQueuePanel.ts

@@ -1,106 +0,0 @@
-export type RenderQueuePanelItemStatus = "queued" | "running" | "done" | "failed";
-
-export interface RenderQueuePanelItem {
-  readonly id: string;
-  readonly label: string;
-  readonly status: RenderQueuePanelItemStatus;
-  readonly progress: number;
-  readonly currentFrame?: number;
-  readonly totalFrames?: number;
-  readonly outputPath?: string;
-  readonly error?: string;
-}
-
-export interface RenderQueuePanelSnapshot {
-  readonly kind: "render-queue-panel";
-  readonly itemCount: number;
-  readonly queuedCount: number;
-  readonly runningCount: number;
-  readonly doneCount: number;
-  readonly failedCount: number;
-  readonly progress: number;
-  readonly items: readonly RenderQueuePanelItem[];
-  readonly outputPaths: readonly string[];
-  readonly errors: readonly string[];
-}
-
-export class RenderQueuePanel {
-  private readonly items = new Map<string, RenderQueuePanelItem>();
-
-  constructor(items: readonly RenderQueuePanelItem[] = []) {
-    for (const item of items) this.upsert(item);
-  }
-
-  upsert(item: RenderQueuePanelItem): RenderQueuePanelSnapshot {
-    this.items.set(item.id, sanitizeRenderQueueItem(item));
-    return this.snapshot();
-  }
-
-  updateProgress(id: string, progress: number, options: {
-    readonly currentFrame?: number;
-    readonly totalFrames?: number;
-    readonly status?: RenderQueuePanelItemStatus;
-    readonly outputPath?: string;
-    readonly error?: string;
-  } = {}): RenderQueuePanelSnapshot {
-    const existing = this.items.get(id);
-    if (!existing) throw new Error(`Render queue item does not exist: ${id}`);
-    return this.upsert({
-      ...existing,
-      progress,
-      status: options.status ?? existing.status,
-      currentFrame: options.currentFrame ?? existing.currentFrame,
-      totalFrames: options.totalFrames ?? existing.totalFrames,
-      outputPath: options.outputPath ?? existing.outputPath,
-      error: options.error ?? existing.error
-    });
-  }
-
-  snapshot(): RenderQueuePanelSnapshot {
-    const items = [...this.items.values()].sort((a, b) => a.id.localeCompare(b.id));
-    const sum = items.reduce((total, item) => total + item.progress, 0);
-    return {
-      kind: "render-queue-panel",
-      itemCount: items.length,
-      queuedCount: items.filter((item) => item.status === "queued").length,
-      runningCount: items.filter((item) => item.status === "running").length,
-      doneCount: items.filter((item) => item.status === "done").length,
-      failedCount: items.filter((item) => item.status === "failed").length,
-      progress: items.length === 0 ? 0 : sum / items.length,
-      items,
-      outputPaths: items.flatMap((item) => item.outputPath ? [item.outputPath] : []),
-      errors: items.flatMap((item) => item.error ? [item.error] : [])
-    };
-  }
-}
-
-export function createRenderQueuePanel(items: readonly RenderQueuePanelItem[] = []): RenderQueuePanel {
-  return new RenderQueuePanel(items);
-}
-
-function sanitizeRenderQueueItem(item: RenderQueuePanelItem): RenderQueuePanelItem {
-  const progress = Number.isFinite(item.progress) ? Math.min(1, Math.max(0, item.progress)) : Number.NaN;
-  if (!Number.isFinite(progress)) throw new Error("Render queue item progress must be finite.");
-  if (item.currentFrame !== undefined && (!Number.isFinite(item.currentFrame) || item.currentFrame < 0)) {
-    throw new Error("Render queue currentFrame must be a non-negative finite number.");
-  }
-  if (item.totalFrames !== undefined && (!Number.isFinite(item.totalFrames) || item.totalFrames <= 0)) {
-    throw new Error("Render queue totalFrames must be a positive finite number.");
-  }
-  return {
-    id: nonEmpty(item.id, "Render queue item id"),
-    label: nonEmpty(item.label, "Render queue item label"),
-    status: item.status,
-    progress,
-    currentFrame: item.currentFrame,
-    totalFrames: item.totalFrames,
-    outputPath: item.outputPath,
-    error: item.error
-  };
-}
-
-function nonEmpty(value: string, label: string): string {
-  const trimmed = value.trim();
-  if (!trimmed) throw new Error(`${label} must be a non-empty string.`);
-  return trimmed;
-}

package/src/RotateGizmo.ts

@@ -1,35 +0,0 @@
-import { Gizmo, type GizmoDrag } from "./Gizmo";
-import { TransformCommand, type TransformLike } from "./commands/TransformCommand";
-
-export class RotateGizmo extends Gizmo {
-  async drag(input: GizmoDrag): Promise<void> {
-    if (!this.target) return;
-    const current = readTransform(this.target);
-    const next = clone(current);
-    next.rotation ??= { x: 0, y: 0, z: 0, w: 1 };
-    const delta = this.snapRotationDelta(input.delta);
-    if (input.axis === "x") next.rotation.x += delta;
-    if (input.axis === "y") next.rotation.y += delta;
-    if (input.axis === "z" || input.axis === "uniform") next.rotation.z += delta;
-    await this.history.execute(new TransformCommand(this.target, next));
-  }
-}
-
-function readTransform(target: NonNullable<RotateGizmo["target"]>): TransformLike {
-  if ("transform" in target) {
-    return {
-      position: { x: target.transform.position[0], y: target.transform.position[1], z: target.transform.position[2] },
-      rotation: { x: target.transform.rotation[0], y: target.transform.rotation[1], z: target.transform.rotation[2], w: target.transform.rotation[3] },
-      scale: { x: target.transform.scale[0], y: target.transform.scale[1], z: target.transform.scale[2] }
-    };
-  }
-  return clone(target);
-}
-
-function clone(transform: TransformLike): TransformLike {
-  return {
-    position: { ...transform.position },
-    rotation: transform.rotation ? { ...transform.rotation } : undefined,
-    scale: transform.scale ? { ...transform.scale } : undefined
-  };
-}

package/src/ScaleGizmo.ts

@@ -1,40 +0,0 @@
-import { Gizmo, type GizmoDrag } from "./Gizmo";
-import { TransformCommand, type TransformLike } from "./commands/TransformCommand";
-
-export class ScaleGizmo extends Gizmo {
-  async drag(input: GizmoDrag): Promise<void> {
-    if (!this.target) return;
-    const current = readTransform(this.target);
-    const next = clone(current);
-    next.scale ??= { x: 1, y: 1, z: 1 };
-    const amount = Math.max(0.001, this.snapScaleFactor(1 + input.delta));
-    if (input.axis === "x") next.scale.x *= amount;
-    if (input.axis === "y") next.scale.y *= amount;
-    if (input.axis === "z") next.scale.z *= amount;
-    if (input.axis === "uniform") {
-      next.scale.x *= amount;
-      next.scale.y *= amount;
-      next.scale.z *= amount;
-    }
-    await this.history.execute(new TransformCommand(this.target, next));
-  }
-}
-
-function readTransform(target: NonNullable<ScaleGizmo["target"]>): TransformLike {
-  if ("transform" in target) {
-    return {
-      position: { x: target.transform.position[0], y: target.transform.position[1], z: target.transform.position[2] },
-      rotation: { x: target.transform.rotation[0], y: target.transform.rotation[1], z: target.transform.rotation[2], w: target.transform.rotation[3] },
-      scale: { x: target.transform.scale[0], y: target.transform.scale[1], z: target.transform.scale[2] }
-    };
-  }
-  return clone(target);
-}
-
-function clone(transform: TransformLike): TransformLike {
-  return {
-    position: { ...transform.position },
-    rotation: transform.rotation ? { ...transform.rotation } : undefined,
-    scale: transform.scale ? { ...transform.scale } : undefined
-  };
-}

package/src/SceneOutliner.ts

@@ -1,78 +0,0 @@
-import { HierarchyModel, type HierarchyNodeDescriptor } from "./HierarchyModel";
-import type { SelectionId } from "./Selection";
-import type { AnimationSceneNode } from "./AnimationSceneEditor";
-
-export interface SceneOutlinerItem extends HierarchyNodeDescriptor {
-  readonly icon: string;
-  readonly kind: string;
-}
-
-export interface SceneOutlinerOptions {
-  readonly selectedIds?: ReadonlySet<SelectionId>;
-  readonly onSelect?: (id: SelectionId) => void;
-}
-
-export class SceneOutliner {
-  private readonly hierarchy = new HierarchyModel();
-  private disposers: (() => void)[] = [];
-
-  describe(root: AnimationSceneNode, selectedIds: ReadonlySet<SelectionId> = new Set()): readonly SceneOutlinerItem[] {
-    return this.hierarchy.flatten(root, selectedIds).map((item) => {
-      const node = findNode(root, String(item.id));
-      const kind = node?.kind ?? "unknown";
-      return {
-        ...item,
-        kind,
-        icon: iconForKind(kind)
-      };
-    });
-  }
-
-  render(root: AnimationSceneNode, container: HTMLElement, options: SceneOutlinerOptions = {}): readonly SceneOutlinerItem[] {
-    this.dispose();
-    const items = this.describe(root, options.selectedIds);
-    container.replaceChildren();
-    const documentRef = container.ownerDocument;
-    for (const item of items) {
-      const row = documentRef.createElement("button");
-      row.type = "button";
-      row.className = "aura-scene-outliner__item";
-      row.dataset.nodeId = String(item.id);
-      row.dataset.kind = item.kind;
-      row.dataset.selected = String(item.selected);
-      row.style.paddingLeft = `${item.depth * 14}px`;
-      row.textContent = `${item.icon} ${item.name}`;
-      const click = (): void => options.onSelect?.(item.id);
-      row.addEventListener("click", click);
-      this.disposers.push(() => row.removeEventListener("click", click));
-      container.append(row);
-    }
-    return items;
-  }
-
-  dispose(): void {
-    for (const dispose of this.disposers.splice(0)) dispose();
-  }
-}
-
-function iconForKind(kind: string): string {
-  switch (kind) {
-    case "character": return "[CHAR]";
-    case "set": return "[SET]";
-    case "prop": return "[PROP]";
-    case "camera": return "[CAM]";
-    case "light": return "[LIGHT]";
-    case "audio": return "[AUD]";
-    case "material": return "[MAT]";
-    default: return "[NODE]";
-  }
-}
-
-function findNode(root: AnimationSceneNode, id: string): AnimationSceneNode | undefined {
-  if (root.id === id) return root;
-  for (const child of root.children) {
-    const found = findNode(child, id);
-    if (found) return found;
-  }
-  return undefined;
-}

package/src/Selection.ts

@@ -1,63 +0,0 @@
-export type SelectionId = string | number;
-
-export interface SelectionChange {
-  readonly previous: readonly SelectionId[];
-  readonly current: readonly SelectionId[];
-}
-
-export type SelectionListener = (change: SelectionChange) => void;
-
-export class Selection {
-  private readonly ids = new Set<SelectionId>();
-  private readonly listeners = new Set<SelectionListener>();
-
-  current(): readonly SelectionId[] {
-    return [...this.ids];
-  }
-
-  has(id: SelectionId): boolean {
-    return this.ids.has(id);
-  }
-
-  set(ids: readonly SelectionId[]): void {
-    this.replace(new Set(ids));
-  }
-
-  add(id: SelectionId): void {
-    this.replace(new Set([...this.ids, id]));
-  }
-
-  remove(id: SelectionId): void {
-    const next = new Set(this.ids);
-    next.delete(id);
-    this.replace(next);
-  }
-
-  clear(): void {
-    this.replace(new Set());
-  }
-
-  subscribe(listener: SelectionListener): () => void {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
-  }
-
-  prune(alive: (id: SelectionId) => boolean): void {
-    this.replace(new Set([...this.ids].filter(alive)));
-  }
-
-  private replace(next: Set<SelectionId>): void {
-    const previous = this.current();
-    this.ids.clear();
-    for (const id of next) {
-      this.ids.add(id);
-    }
-    const current = this.current();
-    if (previous.length !== current.length || previous.some((id, index) => id !== current[index])) {
-      const change = { previous, current };
-      for (const listener of [...this.listeners]) {
-        listener(change);
-      }
-    }
-  }
-}