@treeseed/sdk 0.10.28 → 0.12.4

package/dist/scenes/evidence.js

@@ -0,0 +1,277 @@
+import { createHash } from "node:crypto";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+import { sceneErrorDiagnostic } from "./diagnostics.js";
+import { writeTreeseedSceneEvidenceBundle } from "./evidence-bundle.js";
+import { appendTreeseedSceneEvidencePaths, writeTreeseedSceneEvidenceReport } from "./evidence-report.js";
+import { resolveTreeseedSceneRunRoot } from "./inspect.js";
+import { validateTreeseedScene } from "./planner.js";
+function readJson(path) {
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function sha256(path) {
+  return createHash("sha256").update(readFileSync(path)).digest("hex");
+}
+function fileSize(path) {
+  return statSync(path).size;
+}
+function artifactId(kind, relativePath) {
+  return `${kind}:${relativePath.replace(/[^a-zA-Z0-9._/-]/gu, "-")}`;
+}
+function createArtifact(input) {
+  if (!input.path) return null;
+  const relativePath = relative(input.runRoot, input.path) || input.path;
+  const exists = existsSync(input.path);
+  if (exists && !statSync(input.path).isFile()) return null;
+  return {
+    id: artifactId(input.kind, relativePath),
+    kind: input.kind,
+    path: input.path,
+    relativePath,
+    sha256: exists ? sha256(input.path) : null,
+    bytes: exists ? fileSize(input.path) : null,
+    includedInBundle: input.includedInBundle && exists,
+    redactionStatus: exists ? input.redactionStatus ?? (input.includedInBundle ? "sanitized" : "not-required") : "unknown"
+  };
+}
+function pushArtifact(artifacts, artifact) {
+  if (!artifact) return;
+  if (artifacts.some((entry) => entry.kind === artifact.kind && entry.path === artifact.path)) return;
+  artifacts.push(artifact);
+}
+function listFiles(root) {
+  if (!existsSync(root)) return [];
+  const entries = readdirSync(root, { withFileTypes: true });
+  return entries.flatMap((entry) => {
+    const path = join(root, entry.name);
+    if (entry.isDirectory()) return listFiles(path);
+    return [path];
+  });
+}
+function discoverTrainingOutputs(runRoot) {
+  const trainingRoot = join(runRoot, "training");
+  return [
+    "captions.vtt",
+    "captions.srt",
+    "transcript.json",
+    "transcript.md",
+    "narration.json",
+    "narration.md",
+    "glossary.json",
+    "glossary.md",
+    "chapter-clips.json",
+    "report.json"
+  ].map((name) => join(trainingRoot, name)).filter((path) => existsSync(path));
+}
+function discoverRenderReports(runRoot) {
+  const renderRoot = join(runRoot, "render");
+  if (!existsSync(renderRoot)) return [];
+  return readdirSync(renderRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join(renderRoot, entry.name, "report.json")).filter((path) => existsSync(path));
+}
+function discoverEvidenceArtifacts(input) {
+  const artifacts = [];
+  const runRoot = input.runRoot;
+  pushArtifact(artifacts, createArtifact({ runRoot, kind: "run-report", path: join(runRoot, "run.json"), includedInBundle: true }));
+  pushArtifact(artifacts, createArtifact({ runRoot, kind: "markdown-report", path: join(runRoot, "report.md"), includedInBundle: true }));
+  pushArtifact(artifacts, createArtifact({ runRoot, kind: "timeline", path: join(runRoot, "timeline.json"), includedInBundle: true }));
+  pushArtifact(artifacts, createArtifact({ runRoot, kind: "setup", path: join(runRoot, "setup.json"), includedInBundle: true }));
+  pushArtifact(artifacts, createArtifact({ runRoot, kind: "progress", path: join(runRoot, "progress.jsonl"), includedInBundle: true }));
+  for (const path of listFiles(join(runRoot, "checkpoints"))) pushArtifact(artifacts, createArtifact({ runRoot, kind: "checkpoint", path, includedInBundle: true }));
+  for (const path of listFiles(join(runRoot, "segments")).filter((entry) => entry.endsWith(".json"))) pushArtifact(artifacts, createArtifact({ runRoot, kind: "segment", path, includedInBundle: true }));
+  for (const path of discoverTrainingOutputs(runRoot)) pushArtifact(artifacts, createArtifact({ runRoot, kind: "training-output", path, includedInBundle: true }));
+  for (const path of discoverRenderReports(runRoot)) pushArtifact(artifacts, createArtifact({ runRoot, kind: "render-report", path, includedInBundle: true }));
+  const failedStep = input.run.failedStep ? input.run.steps.find((step) => step.id === input.run.failedStep) : null;
+  if (failedStep?.screenshotPath) pushArtifact(artifacts, createArtifact({ runRoot, kind: "screenshot", path: failedStep.screenshotPath, includedInBundle: true }));
+  for (const path of input.run.artifacts?.screenshotPaths ?? []) {
+    if (path === failedStep?.screenshotPath) continue;
+    pushArtifact(artifacts, createArtifact({ runRoot, kind: "screenshot", path, includedInBundle: false, redactionStatus: "not-required" }));
+  }
+  const tracePath = input.run.playwrightTracePath ?? input.run.artifacts?.playwrightTracePath;
+  pushArtifact(artifacts, createArtifact({ runRoot, kind: "log-summary", path: tracePath, includedInBundle: false, redactionStatus: "excluded-sensitive" }));
+  for (const path of [...input.run.videoPaths, ...input.run.artifacts?.videoPaths ?? []]) {
+    pushArtifact(artifacts, createArtifact({ runRoot, kind: "render-video", path, includedInBundle: false, redactionStatus: "excluded-sensitive" }));
+  }
+  pushArtifact(artifacts, createArtifact({ runRoot, kind: "log-summary", path: input.run.artifacts?.consoleLogPath, includedInBundle: false, redactionStatus: "excluded-sensitive" }));
+  pushArtifact(artifacts, createArtifact({ runRoot, kind: "log-summary", path: input.run.artifacts?.networkLogPath, includedInBundle: false, redactionStatus: "excluded-sensitive" }));
+  pushArtifact(artifacts, createArtifact({ runRoot, kind: "log-summary", path: input.run.artifacts?.errorsLogPath, includedInBundle: false, redactionStatus: "excluded-sensitive" }));
+  for (const path of Object.values(input.run.logs ?? {}).filter((value) => typeof value === "string" && value.length > 0)) {
+    if (path.includes("/training") || path.includes("\\training")) continue;
+    pushArtifact(artifacts, createArtifact({ runRoot, kind: "log-summary", path, includedInBundle: false, redactionStatus: "excluded-sensitive" }));
+  }
+  return artifacts.sort((left, right) => left.kind.localeCompare(right.kind) || left.relativePath.localeCompare(right.relativePath));
+}
+function buildRecommendations(input) {
+  const scene = input.sceneId ?? "(scene)";
+  const run = input.run.runId ?? input.runRoot;
+  const recommendations = [];
+  if (!input.run.ok || input.run.workflowStatus === "failed") {
+    recommendations.push({
+      id: "inspect-failed-run",
+      severity: "warning",
+      command: `trsd scene inspect ${run} --step ${input.run.failedStep ?? ""} --json`.replace(" --step  ", " "),
+      reason: "Inspect the failed scene run before promoting evidence."
+    });
+  }
+  const resumable = input.run.checkpoints.find((checkpoint) => checkpoint.resumable);
+  if (resumable && (!input.run.ok || input.run.workflowStatus === "failed")) {
+    recommendations.push({
+      id: "resume-from-checkpoint",
+      severity: "info",
+      command: `trsd scene resume ${run} --from-checkpoint ${resumable.id} --json`,
+      reason: `Resume from checkpoint ${resumable.id} after repair.`
+    });
+  }
+  if (!input.run.trainingOutputPaths && !input.artifacts.some((artifact) => artifact.kind === "training-output")) {
+    recommendations.push({
+      id: "generate-training",
+      severity: "info",
+      command: `trsd scene training ${scene} --from ${run} --json`,
+      reason: "Generate deterministic captions, transcripts, narration scripts, glossary, and chapter clip manifests."
+    });
+  }
+  if ((input.run.renderedVideoPaths ?? []).length === 0) {
+    recommendations.push({
+      id: "render-video",
+      severity: "info",
+      command: `trsd scene render ${scene} --from ${run} --mode ${input.run.workflowStatus === "failed" ? "failure-review" : "demo"} --json`,
+      reason: "Render a downstream evidence video from the existing run artifacts."
+    });
+  }
+  if (input.target === "release" && input.run.workflowStatus !== "passed") {
+    recommendations.push({
+      id: "release-blocked",
+      severity: "blocking",
+      command: `trsd scene inspect ${run} --json`,
+      reason: "Release evidence is blocked until the scene workflow passes or a release owner accepts the failed evidence."
+    });
+  }
+  return recommendations;
+}
+function buildTreeseedSceneEvidenceManifest(input) {
+  void input.timeline;
+  const target = input.target ?? "local";
+  const bundlePolicy = input.bundlePolicy ?? input.bundle ?? "sanitized";
+  const artifacts = discoverEvidenceArtifacts({ runRoot: input.runRoot, run: input.run });
+  const trainingOutputCount = artifacts.filter((artifact) => artifact.kind === "training-output").length;
+  return {
+    schemaVersion: "treeseed.scene.evidence/v1",
+    phase: 9,
+    generatedAt: input.timestamp ?? nowIso(),
+    target,
+    bundlePolicy,
+    runRoot: input.runRoot,
+    summary: {
+      sceneId: input.scene.id,
+      runId: input.run.runId,
+      workflowStatus: input.run.workflowStatus,
+      ok: input.run.ok,
+      environment: input.run.environment ?? null,
+      startedAt: input.run.startedAt,
+      finishedAt: input.run.finishedAt,
+      durationMs: input.run.durationMs,
+      failedStep: input.run.failedStep,
+      stepCounts: {
+        passed: input.run.steps.filter((step) => step.status === "passed").length,
+        failed: input.run.steps.filter((step) => step.status === "failed").length,
+        skipped: input.run.steps.filter((step) => step.status === "skipped").length
+      },
+      chapters: input.run.chapters.length,
+      segments: input.run.segments.length,
+      checkpoints: input.run.checkpoints.length,
+      renderedVideos: input.run.renderedVideoPaths.length,
+      trainingOutputs: trainingOutputCount > 0
+    },
+    artifacts,
+    recommendations: buildRecommendations({ runRoot: input.runRoot, sceneId: input.scene.id, run: input.run, target, artifacts }),
+    diagnostics: input.run.diagnostics ?? []
+  };
+}
+function writeTreeseedSceneEvidence(input) {
+  const evidenceRoot = join(input.runRoot, "evidence");
+  const paths = {
+    evidenceRoot,
+    manifestPath: join(evidenceRoot, "manifest.json"),
+    reportPath: join(evidenceRoot, "report.md"),
+    bundleRoot: input.manifest.bundlePolicy === "sanitized" ? join(evidenceRoot, "bundle") : null,
+    bundleManifestPath: input.manifest.bundlePolicy === "sanitized" ? join(evidenceRoot, "bundle", "bundle-manifest.json") : null
+  };
+  writeTreeseedSceneEvidenceReport({ manifest: input.manifest, paths });
+  if (input.manifest.bundlePolicy === "sanitized") writeTreeseedSceneEvidenceBundle({ manifest: input.manifest, paths });
+  return paths;
+}
+function failedReport(input) {
+  const blockers = input.blockers ?? input.diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+  return {
+    ok: false,
+    phase: 9,
+    sceneId: null,
+    sourceRunId: null,
+    scenePath: input.scenePath,
+    runRoot: input.runRoot,
+    evidenceRoot: input.runRoot ? join(input.runRoot, "evidence") : null,
+    manifest: null,
+    paths: null,
+    diagnostics: input.diagnostics,
+    warnings: input.warnings ?? input.diagnostics.filter((diagnostic) => diagnostic.severity === "warning"),
+    blockers
+  };
+}
+function generateTreeseedSceneEvidence(input) {
+  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.evidence_missing_scene", `Normalized scene artifact not found: ${scenePath}.`, "scene"));
+  if (!existsSync(runPath)) blockers.push(sceneErrorDiagnostic("scene.evidence_missing_run", `Run report artifact not found: ${runPath}.`, "from"));
+  if (!existsSync(timelinePath)) blockers.push(sceneErrorDiagnostic("scene.evidence_missing_timeline", `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 timeline = readJson(timelinePath);
+  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.evidence_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] });
+  }
+  try {
+    const manifest = buildTreeseedSceneEvidenceManifest({
+      scene: sourceScene,
+      run,
+      timeline,
+      runRoot: resolved.runRoot,
+      target: input.target,
+      bundlePolicy: input.bundlePolicy ?? input.bundle,
+      timestamp: input.timestamp
+    });
+    const paths = writeTreeseedSceneEvidence({ runRoot: resolved.runRoot, manifest });
+    const updateWarnings = appendTreeseedSceneEvidencePaths({ runPath, paths });
+    return {
+      ok: true,
+      phase: 9,
+      sceneId: sourceScene.id,
+      sourceRunId: run.runId,
+      scenePath: validation.scenePath,
+      runRoot: resolved.runRoot,
+      evidenceRoot: paths.evidenceRoot,
+      manifest,
+      paths,
+      diagnostics: updateWarnings,
+      warnings: updateWarnings,
+      blockers: []
+    };
+  } catch (error) {
+    const diagnostic = sceneErrorDiagnostic("scene.evidence_write_failed", `Evidence artifacts could not be written. ${error instanceof Error ? error.message : String(error ?? "")}`.trim(), "evidence");
+    return failedReport({ scenePath: validation.scenePath, runRoot: resolved.runRoot, diagnostics: [diagnostic], blockers: [diagnostic] });
+  }
+}
+export {
+  buildTreeseedSceneEvidenceManifest,
+  generateTreeseedSceneEvidence,
+  writeTreeseedSceneEvidence
+};

package/dist/scenes/index.d.ts

@@ -0,0 +1,48 @@
+export { TREESEED_SCENE_PLATFORM_NAME, createTreeseedScenePhase0Report, planTreeseedSceneArtifactPaths, } from './phase0.js';
+export { formatTreeseedSceneDiagnostics, hasTreeseedSceneErrors, sceneErrorDiagnostic, sceneWarningDiagnostic, } from './diagnostics.js';
+export { loadTreeseedSceneDocument, resolveTreeseedScenePath, } from './loader.js';
+export { createBuiltInTreeseedScenePluginRegistry, findBuiltInTreeseedSceneAction, findBuiltInTreeseedSceneAssertion, listBuiltInTreeseedScenePlugins, listBuiltInTreeseedSceneActions, listBuiltInTreeseedSceneAssertions, listBuiltInTreeseedSceneDiagrams, listBuiltInTreeseedSceneRenderers, resolveTreeseedScenePlugins, } from './registry.js';
+export { createTreeseedScenePluginRegistry, createTreeseedSceneRuntimePluginContext, pluginResolutionFromRegistry, summarizeTreeseedScenePlugins, } from './plugins.js';
+export { defaultTreeseedSceneTrainingConfig, parseTreeseedSceneManifest, sceneActionKind, sceneExpectationKinds, } from './schema.js';
+export { planTreeseedScene, validateTreeseedScene, } from './planner.js';
+export { resolveTreeseedSceneBaseUrl, } from './base-url.js';
+export { prepareTreeseedSceneEnvironment, } from './environment.js';
+export { resolveTreeseedSceneAuth, } from './auth.js';
+export { planOrApplyTreeseedSceneSeed, } from './seed.js';
+export { extractTreeseedSceneOperationIds, waitForTreeseedSceneOperation, } from './operations.js';
+export { collectTreeseedSceneLogs, } from './logs.js';
+export { writeTreeseedSceneRunArtifacts, } from './artifacts.js';
+export { createPlaywrightTreeseedSceneBrowserAdapter, } from './playwright-adapter.js';
+export { formatTreeseedSceneMarkdownReport, writeTreeseedSceneMarkdownReport, } from './reporter.js';
+export { runTreeseedScene, } from './runner.js';
+export { defaultTreeseedSceneDeviceConfig, listTreeseedSceneDeviceProfiles, resolveTreeseedSceneDeviceProfile, } from './devices.js';
+export { runTreeseedSceneDeviceMatrix, } from './device-matrix.js';
+export { discoverTreeseedSceneVisualAuditRoutes, runTreeseedSceneVisualAudit, } from './visual-audit.js';
+export { formatTreeseedSceneVisualAuditMarkdown, writeTreeseedSceneVisualAuditReport, } from './visual-audit-report.js';
+export { buildTreeseedSceneVisualAuditReview, formatTreeseedSceneVisualAuditAgentBrief, formatTreeseedSceneVisualAuditFindingsMarkdown, writeTreeseedSceneVisualAuditReview, } from './visual-audit-review.js';
+export { inspectTreeseedSceneRun, resolveTreeseedSceneRunRoot, } from './inspect.js';
+export { resumeTreeseedScene, } from './resume.js';
+export { createTreeseedSceneProgress, } from './progress.js';
+export { createTreeseedSceneCheckpoint, writeTreeseedSceneCheckpoint, } from './checkpoints.js';
+export { createTreeseedSceneChapterReports, createTreeseedSceneSegment, deriveTreeseedSceneStepChapters, finishTreeseedSceneSegment, writeTreeseedSceneSegmentArtifacts, } from './segments.js';
+export { withTreeseedSceneTimeout, } from './timeouts.js';
+export { renderTreeseedScene, } from './render.js';
+export { loadTreeseedSceneRenderInput, defaultTreeseedSceneRemotionComposition, } from './remotion-input.js';
+export { createRemotionTreeseedSceneRendererAdapter, resolveTreeseedSceneRemotionEntryPoint, } from './remotion-adapter.js';
+export { listTreeseedSceneRemotionCompositions, } from './remotion-composition-registry.js';
+export { createBuiltInTreeseedSceneDiagramProvider, } from './diagram-providers.js';
+export { buildTreeseedSceneRenderDiagrams, resolveTreeseedSceneDiagramDefinition, treeseedSceneDiagramPluginId, validateTreeseedSceneDiagrams, } from './diagram-validation.js';
+export { appendTreeseedSceneRenderedVideo, writeTreeseedSceneRenderReport, } from './render-report.js';
+export { buildTreeseedSceneTrainingOutputs, formatTreeseedSceneCaptionsSrt, formatTreeseedSceneCaptionsVtt, formatTreeseedSceneNarrationMarkdown, formatTreeseedSceneTranscriptMarkdown, generateTreeseedSceneTrainingOutputs, } from './training.js';
+export { writeTreeseedSceneTrainingOutputs, } from './training-report.js';
+export { buildTreeseedSceneEvidenceManifest, generateTreeseedSceneEvidence, writeTreeseedSceneEvidence, } from './evidence.js';
+export { formatTreeseedSceneEvidenceMarkdownReport, writeTreeseedSceneEvidenceReport, } from './evidence-report.js';
+export { buildTreeseedScenePublishManifest, publishTreeseedSceneEvidence, writeTreeseedScenePublish, } from './publish.js';
+export { buildTreeseedScenePublishPlanManifest, exportTreeseedScenePublication, planTreeseedScenePublication, writeTreeseedScenePublishPlan, } from './publish-plan.js';
+export { createDefaultTreeseedSceneRedactionPolicy, validateTreeseedSceneRedactionPolicy, } from './publish-redaction.js';
+export { formatTreeseedScenePublishMarkdownReport, writeTreeseedScenePublishReport, } from './publish-report.js';
+export { formatTreeseedScenePublishPlanMarkdownReport, writeTreeseedScenePublishPlanReport, } from './publish-plan-report.js';
+export { describeTreeseedSceneSelector, resolveTreeseedSceneLocator, } from './selectors.js';
+export { createTreeseedSceneTimeline, } from './timeline.js';
+export type { LoadedTreeseedSceneDocument, TreeseedSceneActionDefinition, TreeseedSceneActionHandler, TreeseedSceneActionHandlerInput, TreeseedSceneActionHandlerResult, TreeseedSceneArtifactWriter, TreeseedSceneArtifactPathPlan, TreeseedSceneArtifacts, TreeseedSceneAssertionDefinition, TreeseedSceneAssertionHandler, TreeseedSceneAssertionHandlerInput, TreeseedSceneAssertionRunReport, TreeseedSceneBrowserAdapter, TreeseedSceneBrowser, TreeseedSceneBrowserLaunchInput, TreeseedSceneBrowserSession, TreeseedSceneCapability, TreeseedSceneCapabilityOwner, TreeseedSceneCapabilityStatus, TreeseedSceneCaptionCue, TreeseedSceneChapterClipManifest, TreeseedSceneCaptureProvider, TreeseedSceneCheckpoint, TreeseedSceneCheckpointStatus, TreeseedSceneChapter, TreeseedSceneDiagnostic, TreeseedSceneDiagnosticSeverity, TreeseedSceneDeviceConfig, TreeseedSceneDeviceMatrixOptions, TreeseedSceneDeviceMatrixReport, TreeseedSceneDeviceOrientation, TreeseedSceneDeviceProfile, TreeseedSceneDeviceProfileId, TreeseedSceneDiagram, TreeseedSceneDiagramDefinition, TreeseedSceneDiagramPlacement, TreeseedSceneDiagramProvider, TreeseedSceneDiagramRenderKind, TreeseedSceneEnvironment, TreeseedSceneEvidenceArtifact, TreeseedSceneEvidenceArtifactKind, TreeseedSceneEvidenceBundlePolicy, TreeseedSceneEvidenceManifest, TreeseedSceneEvidenceOptions, TreeseedSceneEvidencePaths, TreeseedSceneEvidencePhase, TreeseedSceneEvidenceRecommendation, TreeseedSceneEvidenceReport, TreeseedSceneEvidenceSummary, TreeseedSceneEvidenceTarget, TreeseedSceneExpectation, TreeseedSceneGlossaryTerm, TreeseedSceneManifest, TreeseedSceneMode, TreeseedSceneNarrationScriptEntry, TreeseedSceneObservedError, TreeseedSceneOverlay, TreeseedSceneOverlayVariant, TreeseedScenePhase, TreeseedScenePhase0Report, TreeseedScenePlanReport, TreeseedScenePlanStep, TreeseedScenePublishedArtifact, TreeseedSceneExternalPublishTarget, TreeseedScenePublishManifest, TreeseedScenePublishOptions, TreeseedScenePublishPaths, TreeseedScenePublishPhase, TreeseedScenePublishDestination, TreeseedScenePublishPlanArtifact, TreeseedScenePublishPlanManifest, TreeseedScenePublishPlanMode, TreeseedScenePublishPlanOptions, TreeseedScenePublishPlanPaths, TreeseedScenePublishPlanPhase, TreeseedScenePublishPlanReport, TreeseedScenePublishReport, TreeseedScenePublishStatus, TreeseedScenePublishTarget, TreeseedScenePage, TreeseedSceneLocator, TreeseedSceneRedactionDecision, TreeseedSceneRedactionPolicy, TreeseedSceneRedactionRule, TreeseedSceneAuthReport, TreeseedSceneAuthResolveOptions, TreeseedSceneEnvironmentAdapter, TreeseedSceneEnvironmentPrepareOptions, TreeseedSceneEnvironmentPrepareReport, TreeseedSceneExecutionMode, TreeseedSceneInspectOptions, TreeseedSceneInspectReport, TreeseedSceneLogCollectOptions, TreeseedSceneLogCollector, TreeseedSceneLogReport, TreeseedSceneOperationWaitOptions, TreeseedSceneOperationWaitReport, TreeseedSceneOperationWaitSpec, TreeseedSceneOperationWaiter, TreeseedScenePlugin, TreeseedScenePluginCategory, TreeseedScenePluginDiagnostic, TreeseedScenePluginRegistry, TreeseedScenePluginResolution, TreeseedScenePluginStatus, TreeseedScenePluginSummary, TreeseedSceneRenderer, TreeseedSceneRendererAdapter, TreeseedSceneRendererAdapterFactory, TreeseedSceneRendererDefinition, TreeseedSceneRenderConfig, TreeseedSceneRenderCaptureConfig, TreeseedSceneRenderEvidenceFit, TreeseedSceneRenderFormat, TreeseedSceneRenderDiagram, TreeseedSceneRenderInput, TreeseedSceneRenderInputLoadReport, TreeseedSceneRenderMode, TreeseedSceneRenderOptions, TreeseedSceneRenderPhase, TreeseedSceneRenderProgressEvent, TreeseedSceneRenderProgressEventType, TreeseedSceneRenderReport, TreeseedSceneRemotionCompositionDefinition, TreeseedSceneResumeOptions, TreeseedSceneRunArtifacts, TreeseedSceneRunChapterReport, TreeseedSceneRunOptions, TreeseedSceneRunPhase, TreeseedSceneRunReport, TreeseedSceneRunSegmentReport, TreeseedSceneRunSetupReport, TreeseedSceneRunStatus, TreeseedSceneRuntimeConfig, TreeseedSceneTrainingConfig, TreeseedSceneTrainingNarrationStyle, TreeseedSceneTrainingOutputFormat, TreeseedSceneTrainingOutputOptions, TreeseedSceneTrainingOutputPaths, TreeseedSceneTrainingOutputReport, TreeseedSceneTrainingOutputs, TreeseedSceneTranscriptEntry, TreeseedScenePauseController, TreeseedSceneProgressEvent, TreeseedSceneProgressEventType, TreeseedSceneSeedOptions, TreeseedSceneSeedReport, TreeseedSceneSeedRunner, TreeseedSceneRuntimePluginContext, TreeseedSceneRuntimePluginContextInput, TreeseedSceneRunStepReport, TreeseedSceneSchemaVersion, TreeseedSceneSelector, TreeseedSceneSetup, TreeseedSceneStepStatus, TreeseedSceneTarget, TreeseedSceneTimelineEvent, TreeseedSceneTimelineWriter, TreeseedSceneValidationReport, TreeseedSceneVisualObject, TreeseedSceneVisualObjectType, TreeseedSceneVisualAuditCapture, TreeseedSceneVisualAuditClientError, TreeseedSceneVisualAuditClientErrorIncident, TreeseedSceneVisualAuditConfig, TreeseedSceneVisualAuditDomSummary, TreeseedSceneVisualAuditFinding, TreeseedSceneVisualAuditFindingOwner, TreeseedSceneVisualAuditFindingSeverity, TreeseedSceneVisualAuditManifest, TreeseedSceneVisualAuditOptions, TreeseedSceneVisualAuditPaths, TreeseedSceneVisualAuditPhase, TreeseedSceneVisualAuditReport, TreeseedSceneVisualAuditReview, TreeseedSceneVisualAuditReviewCategory, TreeseedSceneVisualAuditReviewDetail, TreeseedSceneVisualAuditReviewSummary, TreeseedSceneVisualAuditRootCause, TreeseedSceneVisualAuditRole, TreeseedSceneVisualAuditRoute, TreeseedSceneVisualAuditRouteSource, TreeseedSceneVisualPoint, TreeseedSceneVisualRegion, TreeseedSceneVisualSize, TreeseedSceneVisualStyle, TreeseedSceneVisualTone, TreeseedSceneVisualUnit, TreeseedSceneMotion, TreeseedSceneMotionEasing, TreeseedSceneMotionKeyframe, TreeseedSceneWorkflowStep, } from './types.js';
+export { TREESEED_SCENE_BROWSERS, TREESEED_SCENE_ENVIRONMENTS, TREESEED_SCENE_SCHEMA_VERSION, } from './types.js';

package/dist/scenes/index.js

@@ -0,0 +1,312 @@
+import {
+  TREESEED_SCENE_PLATFORM_NAME,
+  createTreeseedScenePhase0Report,
+  planTreeseedSceneArtifactPaths
+} from "./phase0.js";
+import {
+  formatTreeseedSceneDiagnostics,
+  hasTreeseedSceneErrors,
+  sceneErrorDiagnostic,
+  sceneWarningDiagnostic
+} from "./diagnostics.js";
+import {
+  loadTreeseedSceneDocument,
+  resolveTreeseedScenePath
+} from "./loader.js";
+import {
+  createBuiltInTreeseedScenePluginRegistry,
+  findBuiltInTreeseedSceneAction,
+  findBuiltInTreeseedSceneAssertion,
+  listBuiltInTreeseedScenePlugins,
+  listBuiltInTreeseedSceneActions,
+  listBuiltInTreeseedSceneAssertions,
+  listBuiltInTreeseedSceneDiagrams,
+  listBuiltInTreeseedSceneRenderers,
+  resolveTreeseedScenePlugins
+} from "./registry.js";
+import {
+  createTreeseedScenePluginRegistry,
+  createTreeseedSceneRuntimePluginContext,
+  pluginResolutionFromRegistry,
+  summarizeTreeseedScenePlugins
+} from "./plugins.js";
+import {
+  defaultTreeseedSceneTrainingConfig,
+  parseTreeseedSceneManifest,
+  sceneActionKind,
+  sceneExpectationKinds
+} from "./schema.js";
+import {
+  planTreeseedScene,
+  validateTreeseedScene
+} from "./planner.js";
+import {
+  resolveTreeseedSceneBaseUrl
+} from "./base-url.js";
+import {
+  prepareTreeseedSceneEnvironment
+} from "./environment.js";
+import {
+  resolveTreeseedSceneAuth
+} from "./auth.js";
+import {
+  planOrApplyTreeseedSceneSeed
+} from "./seed.js";
+import {
+  extractTreeseedSceneOperationIds,
+  waitForTreeseedSceneOperation
+} from "./operations.js";
+import {
+  collectTreeseedSceneLogs
+} from "./logs.js";
+import {
+  writeTreeseedSceneRunArtifacts
+} from "./artifacts.js";
+import {
+  createPlaywrightTreeseedSceneBrowserAdapter
+} from "./playwright-adapter.js";
+import {
+  formatTreeseedSceneMarkdownReport,
+  writeTreeseedSceneMarkdownReport
+} from "./reporter.js";
+import {
+  runTreeseedScene
+} from "./runner.js";
+import {
+  defaultTreeseedSceneDeviceConfig,
+  listTreeseedSceneDeviceProfiles,
+  resolveTreeseedSceneDeviceProfile
+} from "./devices.js";
+import {
+  runTreeseedSceneDeviceMatrix
+} from "./device-matrix.js";
+import {
+  discoverTreeseedSceneVisualAuditRoutes,
+  runTreeseedSceneVisualAudit
+} from "./visual-audit.js";
+import {
+  formatTreeseedSceneVisualAuditMarkdown,
+  writeTreeseedSceneVisualAuditReport
+} from "./visual-audit-report.js";
+import {
+  buildTreeseedSceneVisualAuditReview,
+  formatTreeseedSceneVisualAuditAgentBrief,
+  formatTreeseedSceneVisualAuditFindingsMarkdown,
+  writeTreeseedSceneVisualAuditReview
+} from "./visual-audit-review.js";
+import {
+  inspectTreeseedSceneRun,
+  resolveTreeseedSceneRunRoot
+} from "./inspect.js";
+import {
+  resumeTreeseedScene
+} from "./resume.js";
+import {
+  createTreeseedSceneProgress
+} from "./progress.js";
+import {
+  createTreeseedSceneCheckpoint,
+  writeTreeseedSceneCheckpoint
+} from "./checkpoints.js";
+import {
+  createTreeseedSceneChapterReports,
+  createTreeseedSceneSegment,
+  deriveTreeseedSceneStepChapters,
+  finishTreeseedSceneSegment,
+  writeTreeseedSceneSegmentArtifacts
+} from "./segments.js";
+import {
+  withTreeseedSceneTimeout
+} from "./timeouts.js";
+import {
+  renderTreeseedScene
+} from "./render.js";
+import {
+  loadTreeseedSceneRenderInput,
+  defaultTreeseedSceneRemotionComposition
+} from "./remotion-input.js";
+import {
+  createRemotionTreeseedSceneRendererAdapter,
+  resolveTreeseedSceneRemotionEntryPoint
+} from "./remotion-adapter.js";
+import {
+  listTreeseedSceneRemotionCompositions
+} from "./remotion-composition-registry.js";
+import {
+  createBuiltInTreeseedSceneDiagramProvider
+} from "./diagram-providers.js";
+import {
+  buildTreeseedSceneRenderDiagrams,
+  resolveTreeseedSceneDiagramDefinition,
+  treeseedSceneDiagramPluginId,
+  validateTreeseedSceneDiagrams
+} from "./diagram-validation.js";
+import {
+  appendTreeseedSceneRenderedVideo,
+  writeTreeseedSceneRenderReport
+} from "./render-report.js";
+import {
+  buildTreeseedSceneTrainingOutputs,
+  formatTreeseedSceneCaptionsSrt,
+  formatTreeseedSceneCaptionsVtt,
+  formatTreeseedSceneNarrationMarkdown,
+  formatTreeseedSceneTranscriptMarkdown,
+  generateTreeseedSceneTrainingOutputs
+} from "./training.js";
+import {
+  writeTreeseedSceneTrainingOutputs
+} from "./training-report.js";
+import {
+  buildTreeseedSceneEvidenceManifest,
+  generateTreeseedSceneEvidence,
+  writeTreeseedSceneEvidence
+} from "./evidence.js";
+import {
+  formatTreeseedSceneEvidenceMarkdownReport,
+  writeTreeseedSceneEvidenceReport
+} from "./evidence-report.js";
+import {
+  buildTreeseedScenePublishManifest,
+  publishTreeseedSceneEvidence,
+  writeTreeseedScenePublish
+} from "./publish.js";
+import {
+  buildTreeseedScenePublishPlanManifest,
+  exportTreeseedScenePublication,
+  planTreeseedScenePublication,
+  writeTreeseedScenePublishPlan
+} from "./publish-plan.js";
+import {
+  createDefaultTreeseedSceneRedactionPolicy,
+  validateTreeseedSceneRedactionPolicy
+} from "./publish-redaction.js";
+import {
+  formatTreeseedScenePublishMarkdownReport,
+  writeTreeseedScenePublishReport
+} from "./publish-report.js";
+import {
+  formatTreeseedScenePublishPlanMarkdownReport,
+  writeTreeseedScenePublishPlanReport
+} from "./publish-plan-report.js";
+import {
+  describeTreeseedSceneSelector,
+  resolveTreeseedSceneLocator
+} from "./selectors.js";
+import {
+  createTreeseedSceneTimeline
+} from "./timeline.js";
+import {
+  TREESEED_SCENE_BROWSERS,
+  TREESEED_SCENE_ENVIRONMENTS,
+  TREESEED_SCENE_SCHEMA_VERSION
+} from "./types.js";
+export {
+  TREESEED_SCENE_BROWSERS,
+  TREESEED_SCENE_ENVIRONMENTS,
+  TREESEED_SCENE_PLATFORM_NAME,
+  TREESEED_SCENE_SCHEMA_VERSION,
+  appendTreeseedSceneRenderedVideo,
+  buildTreeseedSceneEvidenceManifest,
+  buildTreeseedScenePublishManifest,
+  buildTreeseedScenePublishPlanManifest,
+  buildTreeseedSceneRenderDiagrams,
+  buildTreeseedSceneTrainingOutputs,
+  buildTreeseedSceneVisualAuditReview,
+  collectTreeseedSceneLogs,
+  createBuiltInTreeseedSceneDiagramProvider,
+  createBuiltInTreeseedScenePluginRegistry,
+  createDefaultTreeseedSceneRedactionPolicy,
+  createPlaywrightTreeseedSceneBrowserAdapter,
+  createRemotionTreeseedSceneRendererAdapter,
+  createTreeseedSceneChapterReports,
+  createTreeseedSceneCheckpoint,
+  createTreeseedScenePhase0Report,
+  createTreeseedScenePluginRegistry,
+  createTreeseedSceneProgress,
+  createTreeseedSceneRuntimePluginContext,
+  createTreeseedSceneSegment,
+  createTreeseedSceneTimeline,
+  defaultTreeseedSceneDeviceConfig,
+  defaultTreeseedSceneRemotionComposition,
+  defaultTreeseedSceneTrainingConfig,
+  deriveTreeseedSceneStepChapters,
+  describeTreeseedSceneSelector,
+  discoverTreeseedSceneVisualAuditRoutes,
+  exportTreeseedScenePublication,
+  extractTreeseedSceneOperationIds,
+  findBuiltInTreeseedSceneAction,
+  findBuiltInTreeseedSceneAssertion,
+  finishTreeseedSceneSegment,
+  formatTreeseedSceneCaptionsSrt,
+  formatTreeseedSceneCaptionsVtt,
+  formatTreeseedSceneDiagnostics,
+  formatTreeseedSceneEvidenceMarkdownReport,
+  formatTreeseedSceneMarkdownReport,
+  formatTreeseedSceneNarrationMarkdown,
+  formatTreeseedScenePublishMarkdownReport,
+  formatTreeseedScenePublishPlanMarkdownReport,
+  formatTreeseedSceneTranscriptMarkdown,
+  formatTreeseedSceneVisualAuditAgentBrief,
+  formatTreeseedSceneVisualAuditFindingsMarkdown,
+  formatTreeseedSceneVisualAuditMarkdown,
+  generateTreeseedSceneEvidence,
+  generateTreeseedSceneTrainingOutputs,
+  hasTreeseedSceneErrors,
+  inspectTreeseedSceneRun,
+  listBuiltInTreeseedSceneActions,
+  listBuiltInTreeseedSceneAssertions,
+  listBuiltInTreeseedSceneDiagrams,
+  listBuiltInTreeseedScenePlugins,
+  listBuiltInTreeseedSceneRenderers,
+  listTreeseedSceneDeviceProfiles,
+  listTreeseedSceneRemotionCompositions,
+  loadTreeseedSceneDocument,
+  loadTreeseedSceneRenderInput,
+  parseTreeseedSceneManifest,
+  planOrApplyTreeseedSceneSeed,
+  planTreeseedScene,
+  planTreeseedSceneArtifactPaths,
+  planTreeseedScenePublication,
+  pluginResolutionFromRegistry,
+  prepareTreeseedSceneEnvironment,
+  publishTreeseedSceneEvidence,
+  renderTreeseedScene,
+  resolveTreeseedSceneAuth,
+  resolveTreeseedSceneBaseUrl,
+  resolveTreeseedSceneDeviceProfile,
+  resolveTreeseedSceneDiagramDefinition,
+  resolveTreeseedSceneLocator,
+  resolveTreeseedScenePath,
+  resolveTreeseedScenePlugins,
+  resolveTreeseedSceneRemotionEntryPoint,
+  resolveTreeseedSceneRunRoot,
+  resumeTreeseedScene,
+  runTreeseedScene,
+  runTreeseedSceneDeviceMatrix,
+  runTreeseedSceneVisualAudit,
+  sceneActionKind,
+  sceneErrorDiagnostic,
+  sceneExpectationKinds,
+  sceneWarningDiagnostic,
+  summarizeTreeseedScenePlugins,
+  treeseedSceneDiagramPluginId,
+  validateTreeseedScene,
+  validateTreeseedSceneDiagrams,
+  validateTreeseedSceneRedactionPolicy,
+  waitForTreeseedSceneOperation,
+  withTreeseedSceneTimeout,
+  writeTreeseedSceneCheckpoint,
+  writeTreeseedSceneEvidence,
+  writeTreeseedSceneEvidenceReport,
+  writeTreeseedSceneMarkdownReport,
+  writeTreeseedScenePublish,
+  writeTreeseedScenePublishPlan,
+  writeTreeseedScenePublishPlanReport,
+  writeTreeseedScenePublishReport,
+  writeTreeseedSceneRenderReport,
+  writeTreeseedSceneRunArtifacts,
+  writeTreeseedSceneSegmentArtifacts,
+  writeTreeseedSceneTrainingOutputs,
+  writeTreeseedSceneVisualAuditReport,
+  writeTreeseedSceneVisualAuditReview
+};

package/dist/scenes/inspect.d.ts

@@ -0,0 +1,9 @@
+import type { TreeseedSceneInspectOptions, TreeseedSceneInspectReport } from './types.js';
+export declare function resolveTreeseedSceneRunRoot(projectRoot: string, run: string): {
+    runRoot: string;
+    diagnostics: never[];
+} | {
+    runRoot: null;
+    diagnostics: import("./types.js").TreeseedSceneDiagnostic[];
+};
+export declare function inspectTreeseedSceneRun(input: TreeseedSceneInspectOptions): TreeseedSceneInspectReport;