@treeseed/sdk 0.11.0 → 0.12.5

package/dist/scenes/publish.js

@@ -0,0 +1,298 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { sceneErrorDiagnostic, sceneWarningDiagnostic } from "./diagnostics.js";
+import { generateTreeseedSceneEvidence } from "./evidence.js";
+import { resolveTreeseedSceneRunRoot } from "./inspect.js";
+import { validateTreeseedScene } from "./planner.js";
+import {
+  createDefaultTreeseedSceneRedactionPolicy,
+  readTreeseedSceneRedactionPolicyFile,
+  resolveTreeseedSceneRedactionRule,
+  validateTreeseedSceneRedactionPolicy
+} from "./publish-redaction.js";
+import { appendTreeseedScenePublishPaths, writeTreeseedScenePublishReport } from "./publish-report.js";
+import { treeseedSceneReleaseEvidenceRecordPath, writeTreeseedSceneReleaseEvidenceRecord } from "./publish-release-record.js";
+function readJson(path) {
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+function writeJson(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function safeBundlePath(bundleRoot, relativePath) {
+  return join(bundleRoot, relativePath.replace(/^(\.\.[/\\])+/u, "").replace(/^[/\\]+/u, ""));
+}
+function failedReport(input) {
+  const blockers = input.blockers ?? input.diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+  return {
+    ok: false,
+    phase: 10,
+    status: "blocked",
+    sceneId: input.sceneId ?? null,
+    sourceRunId: input.sourceRunId ?? null,
+    scenePath: input.scenePath,
+    runRoot: input.runRoot,
+    evidenceRoot: input.evidenceRoot ?? (input.runRoot ? join(input.runRoot, "evidence") : null),
+    publishRoot: input.publishRoot ?? (input.runRoot ? join(input.runRoot, "publish") : null),
+    manifest: input.manifest ?? null,
+    paths: input.paths ?? null,
+    diagnostics: input.diagnostics,
+    warnings: input.warnings ?? input.diagnostics.filter((diagnostic) => diagnostic.severity === "warning"),
+    blockers
+  };
+}
+function defaultIncluded(input) {
+  return input.policy.id === "treeseed.scene.redaction.default" && input.artifact.kind === "screenshot" && !input.artifact.includedInBundle ? false : true;
+}
+function publishDecision(input) {
+  if (!existsSync(input.artifact.path) || !statSync(input.artifact.path).isFile()) {
+    return {
+      id: input.artifact.id,
+      kind: input.artifact.kind,
+      sourcePath: input.artifact.path,
+      publishedPath: null,
+      relativePath: input.artifact.relativePath,
+      sha256: input.artifact.sha256,
+      bytes: input.artifact.bytes,
+      decision: "missing",
+      reason: "Source artifact is missing."
+    };
+  }
+  if (input.artifact.redactionStatus === "excluded-sensitive") {
+    return {
+      id: input.artifact.id,
+      kind: input.artifact.kind,
+      sourcePath: input.artifact.path,
+      publishedPath: null,
+      relativePath: input.artifact.relativePath,
+      sha256: input.artifact.sha256,
+      bytes: input.artifact.bytes,
+      decision: "exclude-sensitive",
+      reason: "Artifact was marked sensitive by evidence generation."
+    };
+  }
+  const rule = resolveTreeseedSceneRedactionRule({
+    policy: input.policy,
+    artifactKind: input.artifact.kind,
+    target: input.target,
+    workflowStatus: input.workflowStatus
+  });
+  if (!rule || !defaultIncluded({ artifact: input.artifact, policy: input.policy })) {
+    return {
+      id: input.artifact.id,
+      kind: input.artifact.kind,
+      sourcePath: input.artifact.path,
+      publishedPath: null,
+      relativePath: input.artifact.relativePath,
+      sha256: input.artifact.sha256,
+      bytes: input.artifact.bytes,
+      decision: "exclude-not-allowed",
+      reason: rule?.reason ?? "No redaction rule allowed this artifact."
+    };
+  }
+  if (!rule.include) {
+    return {
+      id: input.artifact.id,
+      kind: input.artifact.kind,
+      sourcePath: input.artifact.path,
+      publishedPath: null,
+      relativePath: input.artifact.relativePath,
+      sha256: input.artifact.sha256,
+      bytes: input.artifact.bytes,
+      decision: input.artifact.redactionStatus === "excluded-sensitive" ? "exclude-sensitive" : "exclude-not-allowed",
+      reason: rule.reason
+    };
+  }
+  return {
+    id: input.artifact.id,
+    kind: input.artifact.kind,
+    sourcePath: input.artifact.path,
+    publishedPath: null,
+    relativePath: input.artifact.relativePath,
+    sha256: input.artifact.sha256,
+    bytes: input.artifact.bytes,
+    decision: "include",
+    reason: rule.reason
+  };
+}
+function buildTreeseedScenePublishManifest(input) {
+  const redactionPolicy = input.redactionPolicy ?? createDefaultTreeseedSceneRedactionPolicy(input.target);
+  const policyDiagnostics = validateTreeseedSceneRedactionPolicy({ policy: redactionPolicy });
+  const artifacts = input.evidence.artifacts.map((artifact) => publishDecision({
+    artifact,
+    policy: redactionPolicy,
+    target: input.target,
+    workflowStatus: input.evidence.summary.workflowStatus
+  }));
+  const diagnostics = [...input.evidence.diagnostics, ...policyDiagnostics];
+  if (artifacts.every((artifact) => artifact.decision !== "include")) {
+    diagnostics.push(sceneErrorDiagnostic("scene.publish_no_artifacts", "Redaction policy did not include any publishable evidence artifacts.", "publish"));
+  }
+  return {
+    schemaVersion: "treeseed.scene.publish/v1",
+    phase: 10,
+    generatedAt: input.timestamp ?? nowIso(),
+    target: input.target,
+    sourceEvidenceManifestPath: input.evidencePath,
+    sourceRunRoot: input.runRoot,
+    sceneId: input.evidence.summary.sceneId,
+    sourceRunId: input.evidence.summary.runId,
+    workflowStatus: input.evidence.summary.workflowStatus,
+    redactionPolicy,
+    artifacts,
+    releaseRecordPath: null,
+    diagnostics
+  };
+}
+function writeTreeseedScenePublish(input) {
+  const publishRoot = join(input.runRoot, "publish", input.manifest.target);
+  const paths = {
+    publishRoot,
+    manifestPath: join(publishRoot, "manifest.json"),
+    reportPath: join(publishRoot, "report.md"),
+    bundleRoot: join(publishRoot, "bundle"),
+    releaseRecordPath: input.manifest.target === "release" && input.projectRoot ? treeseedSceneReleaseEvidenceRecordPath({ projectRoot: input.projectRoot, sceneId: input.manifest.sceneId, runId: input.manifest.sourceRunId }) : null
+  };
+  const copiedArtifacts = input.manifest.artifacts.map((artifact) => {
+    if (artifact.decision !== "include" || !existsSync(artifact.sourcePath)) return artifact;
+    const targetPath = safeBundlePath(paths.bundleRoot, artifact.relativePath);
+    mkdirSync(dirname(targetPath), { recursive: true });
+    copyFileSync(artifact.sourcePath, targetPath);
+    return {
+      ...artifact,
+      publishedPath: targetPath,
+      relativePath: relative(paths.bundleRoot, targetPath)
+    };
+  });
+  const manifest = {
+    ...input.manifest,
+    releaseRecordPath: paths.releaseRecordPath,
+    artifacts: copiedArtifacts
+  };
+  mkdirSync(paths.bundleRoot, { recursive: true });
+  writeJson(join(paths.bundleRoot, "bundle-manifest.json"), {
+    schemaVersion: "treeseed.scene.publish-bundle/v1",
+    generatedAt: manifest.generatedAt,
+    target: manifest.target,
+    sceneId: manifest.sceneId,
+    sourceRunId: manifest.sourceRunId,
+    artifacts: copiedArtifacts
+  });
+  if (manifest.target === "release" && input.projectRoot) {
+    writeTreeseedSceneReleaseEvidenceRecord({
+      projectRoot: input.projectRoot,
+      manifest,
+      manifestPath: paths.manifestPath,
+      reportPath: paths.reportPath,
+      bundleRoot: paths.bundleRoot
+    });
+  }
+  writeTreeseedScenePublishReport({ manifest, paths });
+  return paths;
+}
+function loadOrGenerateEvidence(input) {
+  const evidencePath = join(input.runRoot, "evidence", "manifest.json");
+  if (existsSync(evidencePath)) {
+    return { evidence: readJson(evidencePath), evidencePath, warnings: [], diagnostics: [] };
+  }
+  const report = generateTreeseedSceneEvidence({
+    projectRoot: input.projectRoot,
+    scene: input.scene,
+    from: input.from,
+    target: input.target === "release" ? "release" : "local",
+    bundlePolicy: "sanitized",
+    timestamp: input.timestamp
+  });
+  if (!report.ok || !report.manifest || !report.paths) {
+    return { evidence: null, evidencePath, warnings: report.warnings, diagnostics: report.diagnostics };
+  }
+  const warning = sceneWarningDiagnostic("scene.publish_generated_evidence", "Evidence manifest was missing, so publish generated sanitized Phase 9 evidence first.", "evidence");
+  return { evidence: report.manifest, evidencePath: report.paths.manifestPath, warnings: [warning, ...report.warnings], diagnostics: [warning, ...report.diagnostics] };
+}
+async function publishTreeseedSceneEvidence(input) {
+  const target = input.target ?? "local";
+  if (!["local", "release"].includes(target)) {
+    const diagnostic = sceneErrorDiagnostic("scene.publish_target_unsupported", `Unsupported scene publish target "${String(target)}".`, "target");
+    return failedReport({ scenePath: input.scene, runRoot: null, diagnostics: [diagnostic], blockers: [diagnostic] });
+  }
+  const resolved = resolveTreeseedSceneRunRoot(input.projectRoot, input.from);
+  if (!resolved.runRoot) return failedReport({ scenePath: input.scene, runRoot: null, diagnostics: resolved.diagnostics });
+  const scenePath = join(resolved.runRoot, "scene.normalized.json");
+  const runPath = join(resolved.runRoot, "run.json");
+  const timelinePath = join(resolved.runRoot, "timeline.json");
+  const blockers = [];
+  if (!existsSync(scenePath)) blockers.push(sceneErrorDiagnostic("scene.publish_missing_evidence", `Normalized scene artifact not found: ${scenePath}.`, "scene"));
+  if (!existsSync(runPath)) blockers.push(sceneErrorDiagnostic("scene.publish_missing_evidence", `Run report artifact not found: ${runPath}.`, "from"));
+  if (!existsSync(timelinePath)) blockers.push(sceneErrorDiagnostic("scene.publish_missing_evidence", `Timeline artifact not found: ${timelinePath}.`, "from"));
+  if (blockers.length > 0) return failedReport({ scenePath: input.scene, runRoot: resolved.runRoot, diagnostics: [...resolved.diagnostics, ...blockers], blockers });
+  const sourceScene = readJson(scenePath);
+  const run = readJson(runPath);
+  const validation = validateTreeseedScene({ projectRoot: input.projectRoot, scene: input.scene });
+  if (!validation.ok) return failedReport({ scenePath: validation.scenePath, runRoot: resolved.runRoot, diagnostics: validation.diagnostics });
+  if (validation.scene?.id !== sourceScene.id) {
+    const diagnostic = sceneErrorDiagnostic("scene.publish_scene_mismatch", `Scene manifest "${validation.scene?.id ?? "(unknown)"}" does not match source run scene "${sourceScene.id}".`, "scene");
+    return failedReport({ scenePath: validation.scenePath, runRoot: resolved.runRoot, diagnostics: [diagnostic], blockers: [diagnostic], sceneId: sourceScene.id, sourceRunId: run.runId });
+  }
+  const policyResult = input.redactionPolicyPath ? readTreeseedSceneRedactionPolicyFile(input.redactionPolicyPath) : { policy: createDefaultTreeseedSceneRedactionPolicy(target), diagnostics: [] };
+  if (!policyResult.policy || policyResult.diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+    return failedReport({ scenePath: validation.scenePath, runRoot: resolved.runRoot, diagnostics: policyResult.diagnostics, blockers: policyResult.diagnostics.filter((diagnostic) => diagnostic.severity === "error"), sceneId: sourceScene.id, sourceRunId: run.runId });
+  }
+  const evidenceResult = loadOrGenerateEvidence({ projectRoot: input.projectRoot, scene: input.scene, from: input.from, runRoot: resolved.runRoot, target, timestamp: input.timestamp });
+  if (!evidenceResult.evidence) return failedReport({ scenePath: validation.scenePath, runRoot: resolved.runRoot, diagnostics: evidenceResult.diagnostics, warnings: evidenceResult.warnings, blockers: evidenceResult.diagnostics.filter((diagnostic) => diagnostic.severity === "error"), sceneId: sourceScene.id, sourceRunId: run.runId });
+  const manifest = buildTreeseedScenePublishManifest({
+    evidence: evidenceResult.evidence,
+    evidencePath: evidenceResult.evidencePath,
+    runRoot: resolved.runRoot,
+    target,
+    redactionPolicy: policyResult.policy,
+    timestamp: input.timestamp
+  });
+  const manifestErrors = manifest.diagnostics.filter((diagnostic) => diagnostic.severity === "error" && diagnostic.code.startsWith("scene.publish_"));
+  if (target === "release" && manifest.workflowStatus !== "passed") {
+    manifestErrors.push(sceneErrorDiagnostic("scene.publish_release_blocked", "Release evidence publication is blocked until the scene workflow passes.", "target"));
+  }
+  if (manifestErrors.length > 0) {
+    return failedReport({
+      scenePath: validation.scenePath,
+      runRoot: resolved.runRoot,
+      diagnostics: [...evidenceResult.diagnostics, ...manifest.diagnostics, ...manifestErrors],
+      warnings: evidenceResult.warnings,
+      blockers: manifestErrors,
+      sceneId: sourceScene.id,
+      sourceRunId: run.runId,
+      manifest
+    });
+  }
+  try {
+    const paths = writeTreeseedScenePublish({ runRoot: resolved.runRoot, manifest, evidence: evidenceResult.evidence, projectRoot: input.projectRoot });
+    const updateWarnings = appendTreeseedScenePublishPaths({ runPath, paths });
+    return {
+      ok: true,
+      phase: 10,
+      status: "published",
+      sceneId: sourceScene.id,
+      sourceRunId: run.runId,
+      scenePath: validation.scenePath,
+      runRoot: resolved.runRoot,
+      evidenceRoot: join(resolved.runRoot, "evidence"),
+      publishRoot: paths.publishRoot,
+      manifest: readJson(paths.manifestPath),
+      paths,
+      diagnostics: [...evidenceResult.diagnostics, ...updateWarnings],
+      warnings: [...evidenceResult.warnings, ...updateWarnings],
+      blockers: []
+    };
+  } catch (error) {
+    const diagnostic = sceneErrorDiagnostic("scene.publish_write_failed", `Publish artifacts could not be written. ${error instanceof Error ? error.message : String(error ?? "")}`.trim(), "publish");
+    return failedReport({ scenePath: validation.scenePath, runRoot: resolved.runRoot, diagnostics: [diagnostic], warnings: evidenceResult.warnings, blockers: [diagnostic], sceneId: sourceScene.id, sourceRunId: run.runId, manifest });
+  }
+}
+export {
+  buildTreeseedScenePublishManifest,
+  publishTreeseedSceneEvidence,
+  writeTreeseedScenePublish
+};

package/dist/scenes/registry.d.ts

@@ -0,0 +1,12 @@
+import type { TreeseedSceneActionDefinition, TreeseedSceneAssertionDefinition, TreeseedSceneDiagramDefinition, TreeseedScenePlugin, TreeseedSceneRendererDefinition } from './types.js';
+export declare function createBuiltInTreeseedScenePluginRegistry(): import("./types.js").TreeseedScenePluginRegistry;
+export declare function resolveTreeseedScenePlugins(input?: {
+    plugins?: TreeseedScenePlugin[];
+}): import("./types.js").TreeseedScenePluginResolution;
+export declare function listBuiltInTreeseedScenePlugins(): import("./types.js").TreeseedScenePluginSummary[];
+export declare function listBuiltInTreeseedSceneActions(): TreeseedSceneActionDefinition[];
+export declare function listBuiltInTreeseedSceneAssertions(): TreeseedSceneAssertionDefinition[];
+export declare function listBuiltInTreeseedSceneRenderers(): TreeseedSceneRendererDefinition[];
+export declare function listBuiltInTreeseedSceneDiagrams(): TreeseedSceneDiagramDefinition[];
+export declare function findBuiltInTreeseedSceneAction(id: string): TreeseedSceneActionDefinition | null;
+export declare function findBuiltInTreeseedSceneAssertion(id: string): TreeseedSceneAssertionDefinition | null;

package/dist/scenes/registry.js

@@ -0,0 +1,65 @@
+import { createBuiltInTreeseedScenePlugins } from "./builtin-plugins.js";
+import { createTreeseedScenePluginRegistry, pluginResolutionFromRegistry, summarizeTreeseedScenePlugins } from "./plugins.js";
+function createBuiltInTreeseedScenePluginRegistry() {
+  return createTreeseedScenePluginRegistry(createBuiltInTreeseedScenePlugins());
+}
+function resolveTreeseedScenePlugins(input = {}) {
+  return pluginResolutionFromRegistry(createTreeseedScenePluginRegistry([
+    ...createBuiltInTreeseedScenePlugins(),
+    ...input.plugins ?? []
+  ]));
+}
+function listBuiltInTreeseedScenePlugins() {
+  return summarizeTreeseedScenePlugins(createBuiltInTreeseedScenePlugins());
+}
+function listBuiltInTreeseedSceneActions() {
+  const registry = createBuiltInTreeseedScenePluginRegistry();
+  return [...registry.actions.entries()].map(([id, action]) => ({
+    id,
+    phase: action.phase,
+    pluginId: registry.actionPlugins.get(id) ?? "unknown",
+    status: action.status,
+    summary: action.summary
+  })).sort((a, b) => a.id.localeCompare(b.id));
+}
+function listBuiltInTreeseedSceneAssertions() {
+  const registry = createBuiltInTreeseedScenePluginRegistry();
+  return [...registry.assertions.entries()].map(([id, assertion]) => ({
+    id,
+    phase: assertion.phase,
+    pluginId: registry.assertionPlugins.get(id) ?? "unknown",
+    status: assertion.status,
+    summary: assertion.summary
+  })).sort((a, b) => a.id.localeCompare(b.id));
+}
+function listBuiltInTreeseedSceneRenderers() {
+  const registry = createBuiltInTreeseedScenePluginRegistry();
+  return [...registry.renderers.entries()].map(([id, renderer]) => ({
+    id,
+    phase: renderer.phase,
+    pluginId: registry.rendererPlugins.get(id) ?? "unknown",
+    status: renderer.status,
+    summary: renderer.summary
+  })).sort((a, b) => a.id.localeCompare(b.id));
+}
+function listBuiltInTreeseedSceneDiagrams() {
+  const registry = createBuiltInTreeseedScenePluginRegistry();
+  return [...registry.diagrams.values()].flatMap((provider) => Object.values(provider.diagrams)).sort((a, b) => a.component.localeCompare(b.component));
+}
+function findBuiltInTreeseedSceneAction(id) {
+  return listBuiltInTreeseedSceneActions().find((action) => action.id === id) ?? null;
+}
+function findBuiltInTreeseedSceneAssertion(id) {
+  return listBuiltInTreeseedSceneAssertions().find((assertion) => assertion.id === id) ?? null;
+}
+export {
+  createBuiltInTreeseedScenePluginRegistry,
+  findBuiltInTreeseedSceneAction,
+  findBuiltInTreeseedSceneAssertion,
+  listBuiltInTreeseedSceneActions,
+  listBuiltInTreeseedSceneAssertions,
+  listBuiltInTreeseedSceneDiagrams,
+  listBuiltInTreeseedScenePlugins,
+  listBuiltInTreeseedSceneRenderers,
+  resolveTreeseedScenePlugins
+};

package/dist/scenes/remotion-adapter.d.ts

@@ -0,0 +1,3 @@
+import type { TreeseedSceneRendererAdapter } from './types.js';
+export declare function createRemotionTreeseedSceneRendererAdapter(): TreeseedSceneRendererAdapter;
+export declare function resolveTreeseedSceneRemotionEntryPoint(): string;

package/dist/scenes/remotion-adapter.js

@@ -0,0 +1,94 @@
+import { dirname, join } from "node:path";
+import { availableParallelism } from "node:os";
+import { fileURLToPath } from "node:url";
+import { sceneErrorDiagnostic } from "./diagnostics.js";
+function remotionEntryPoint() {
+  const current = fileURLToPath(import.meta.url);
+  const extension = current.endsWith(".ts") ? ".ts" : ".js";
+  return join(dirname(current), `remotion-compositions${extension}`);
+}
+function remotionDiagnostic(error, fallbackCode, fallbackMessage) {
+  const message = error instanceof Error ? error.message : String(error ?? fallbackMessage);
+  const lower = message.toLowerCase();
+  if (lower.includes("browser") || lower.includes("chrome") || lower.includes("chromium")) {
+    return sceneErrorDiagnostic("scene.remotion_browser_missing", `${fallbackMessage} ${message}`.trim(), "renderer");
+  }
+  return sceneErrorDiagnostic(fallbackCode, `${fallbackMessage} ${message}`.trim(), "renderer");
+}
+function remotionConcurrency() {
+  const raw = process.env.TREESEED_SCENE_REMOTION_CONCURRENCY;
+  const parsed = raw ? Number(raw) : 4;
+  const max = Math.max(1, availableParallelism());
+  if (!Number.isFinite(parsed)) return 4;
+  return Math.max(1, Math.min(max, Math.floor(parsed)));
+}
+function createRemotionTreeseedSceneRendererAdapter() {
+  return {
+    id: "remotion",
+    async render(input) {
+      let bundle;
+      let selectComposition;
+      let renderMedia;
+      try {
+        const [bundler, renderer] = await Promise.all([
+          import("@remotion/bundler"),
+          import("@remotion/renderer")
+        ]);
+        bundle = bundler.bundle;
+        selectComposition = renderer.selectComposition;
+        renderMedia = renderer.renderMedia;
+      } catch (error) {
+        return {
+          ok: false,
+          outputPath: null,
+          diagnostics: [sceneErrorDiagnostic("scene.remotion_unavailable", `Install SDK dependencies and ensure remotion, @remotion/renderer, and @remotion/bundler are available. ${error instanceof Error ? error.message : String(error ?? "")}`.trim(), "renderer")]
+        };
+      }
+      let serveUrl;
+      try {
+        input.onProgress?.({ type: "bundle.started" });
+        serveUrl = await bundle({
+          entryPoint: input.entryPoint || remotionEntryPoint(),
+          ...input.publicDir ? { publicDir: input.publicDir } : {}
+        });
+        input.onProgress?.({ type: "bundle.finished", serveUrl });
+      } catch (error) {
+        return { ok: false, outputPath: null, diagnostics: [remotionDiagnostic(error, "scene.remotion_bundle_failed", "Unable to bundle Remotion scene composition.")] };
+      }
+      let composition;
+      try {
+        input.onProgress?.({ type: "composition.selected", compositionId: input.compositionId });
+        composition = await selectComposition({
+          serveUrl,
+          id: input.compositionId,
+          inputProps: input.inputProps
+        });
+      } catch (error) {
+        return { ok: false, outputPath: null, diagnostics: [remotionDiagnostic(error, "scene.remotion_composition_failed", "Unable to select Remotion scene composition.")] };
+      }
+      try {
+        input.onProgress?.({ type: "media.started", outputPath: input.outputPath });
+        await renderMedia({
+          serveUrl,
+          composition,
+          codec: input.codec,
+          outputLocation: input.outputPath,
+          inputProps: input.inputProps,
+          concurrency: remotionConcurrency(),
+          onProgress: (progress) => input.onProgress?.({ type: "media.progress", ...progress })
+        });
+        input.onProgress?.({ type: "media.finished", outputPath: input.outputPath });
+        return { ok: true, outputPath: input.outputPath, diagnostics: [] };
+      } catch (error) {
+        return { ok: false, outputPath: null, diagnostics: [remotionDiagnostic(error, "scene.remotion_render_failed", "Unable to render Remotion scene video.")] };
+      }
+    }
+  };
+}
+function resolveTreeseedSceneRemotionEntryPoint() {
+  return remotionEntryPoint();
+}
+export {
+  createRemotionTreeseedSceneRendererAdapter,
+  resolveTreeseedSceneRemotionEntryPoint
+};

package/dist/scenes/remotion-composition-registry.d.ts

@@ -0,0 +1,2 @@
+import type { TreeseedSceneRemotionCompositionDefinition } from './types.js';
+export declare function listTreeseedSceneRemotionCompositions(): TreeseedSceneRemotionCompositionDefinition[];

package/dist/scenes/remotion-composition-registry.js

@@ -0,0 +1,12 @@
+const COMPOSITIONS = [
+  { id: "treeseed-demo-default", phase: 6, mode: "demo", summary: "Default Treeseed demo video with browser evidence, chapters, lower thirds, and callouts." },
+  { id: "treeseed-training-default", phase: 6, mode: "training", summary: "Training-oriented render profile with larger context and persistent chapter labels." },
+  { id: "treeseed-failure-review", phase: 6, mode: "failure-review", summary: "Failure review render focused on failed step diagnostics and evidence." },
+  { id: "treeseed-diagram-only", phase: 6, mode: "diagram-only", summary: "Render typed scene diagrams from validated diagram provider input." }
+];
+function listTreeseedSceneRemotionCompositions() {
+  return [...COMPOSITIONS];
+}
+export {
+  listTreeseedSceneRemotionCompositions
+};

package/dist/scenes/remotion-compositions.d.ts

@@ -0,0 +1,15 @@
+import type { TreeseedSceneRenderInput } from './types.js';
+export declare function treeseedSceneRenderLayout(input: TreeseedSceneRenderInput): {
+    introFrames: number;
+    interstitialFrames: number;
+    evidenceStartFrame: number;
+    evidenceDurationInFrames: number;
+};
+export declare function resolveEvidenceViewport(input: TreeseedSceneRenderInput): {
+    width: number;
+    height: number;
+    scale: number;
+    left: number;
+    top: number;
+};
+export declare function TreeseedSceneRemotionRoot(): any;