@treeseed/sdk 0.13.0-rc.2 → 0.13.0-rc.21

package/dist/scenes/support/evidence/timeline.d.ts

@@ -1,11 +0,0 @@
-import type { SceneTimelineEvent } from '../../types.js';
-export type SceneTimelineWriter = {
-    events: SceneTimelineEvent[];
-    push(type: SceneTimelineEvent['type'], data: Record<string, unknown>, stepId?: string): SceneTimelineEvent;
-};
-export declare function createSceneTimeline(input: {
-    sceneId: string;
-    runId: string;
-    startedAtMs: number;
-    now?: () => Date;
-}): SceneTimelineWriter;

package/dist/scenes/support/evidence/timeline.js

@@ -1,26 +0,0 @@
-function createSceneTimeline(input) {
-  const events = [];
-  const now = input.now ?? (() => /* @__PURE__ */ new Date());
-  let sequence = 0;
-  return {
-    events,
-    push(type, data, stepId) {
-      const timestamp = now();
-      const event = {
-        id: `${input.runId}-${String(sequence += 1).padStart(5, "0")}`,
-        type,
-        sceneId: input.sceneId,
-        runId: input.runId,
-        ...stepId ? { stepId } : {},
-        timestamp: timestamp.toISOString(),
-        offsetMs: Math.max(0, timestamp.getTime() - input.startedAtMs),
-        data
-      };
-      events.push(event);
-      return event;
-    }
-  };
-}
-export {
-  createSceneTimeline
-};

package/dist/scenes/support/execution/base-url.d.ts

@@ -1,12 +0,0 @@
-import type { SceneBaseUrlResolution, SceneEnvironment, SceneEnvironmentPrepareReport, SceneManifest } from '../../types.js';
-export declare function resolveSceneBaseUrl(input: {
-    projectRoot: string;
-    scene: SceneManifest;
-    environment: SceneEnvironment;
-    environmentReport?: SceneEnvironmentPrepareReport | null;
-}): SceneBaseUrlResolution;
-export declare function resolveSceneApiBaseUrl(input: {
-    projectRoot: string;
-    environment: SceneEnvironment | string;
-    webBaseUrl: string;
-}): string;

package/dist/scenes/support/execution/base-url.js

@@ -1,123 +0,0 @@
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-import { readDevInstance } from "../../../local-dev/managed-dev.js";
-import { loadDeployConfigFromPath } from "../../../platform/hosting/deploy-config.js";
-import { sceneErrorDiagnostic } from "../reporting/diagnostics.js";
-function resolveSceneBaseUrl(input) {
-  if (input.scene.target.baseUrl !== "auto") {
-    return { ok: true, baseUrl: input.scene.target.baseUrl, diagnostics: [] };
-  }
-  if (input.environment !== "local") {
-    const configured = configuredHostedBaseUrl(input.projectRoot, input.environment);
-    if (configured) return { ok: true, baseUrl: configured, diagnostics: [] };
-    return {
-      ok: false,
-      baseUrl: null,
-      diagnostics: [
-        sceneErrorDiagnostic(
-          "scene.base_url_unresolved",
-          "Automatic staging/prod base URL resolution requires a configured Treeseed deploy base URL.",
-          "target.baseUrl"
-        )
-      ]
-    };
-  }
-  if (input.environmentReport?.dev.baseUrl) {
-    return { ok: true, baseUrl: input.environmentReport.dev.baseUrl, diagnostics: [] };
-  }
-  const instance = readDevInstance({ cwd: input.projectRoot, surface: "web" });
-  const healthUrl = instance?.health?.find((entry) => entry.kind === "http")?.url ?? null;
-  if (!instance?.running || !healthUrl) {
-    return {
-      ok: false,
-      baseUrl: null,
-      diagnostics: [
-        sceneErrorDiagnostic(
-          "scene.local_dev_not_running",
-          "Start local dev with trsd dev start --web-runtime local --json or set target.baseUrl explicitly.",
-          "target.baseUrl"
-        )
-      ]
-    };
-  }
-  return { ok: true, baseUrl: healthUrl, diagnostics: [] };
-}
-function configuredHostedBaseUrl(projectRoot, environment) {
-  const candidates = [
-    resolve(projectRoot, "treeseed.site.yaml"),
-    resolve(projectRoot, "..", "..", "treeseed.site.yaml")
-  ];
-  for (const candidate of candidates) {
-    if (!existsSync(candidate)) continue;
-    try {
-      const config = loadDeployConfigFromPath(candidate);
-      const serviceUrl = hostedWebUrl(config.services?.web?.environments?.[environment]) ?? hostedWebUrl(config.surfaces?.web?.environments?.[environment]) ?? (environment === "prod" ? config.surfaces?.web?.publicBaseUrl : void 0);
-      if (typeof serviceUrl === "string" && serviceUrl.trim()) return serviceUrl.trim();
-    } catch {
-    }
-  }
-  if (environment === "prod") return "https://treeseed.dev";
-  if (environment === "staging") return "https://preview.treeseed.dev";
-  return null;
-}
-function hostedWebUrl(environmentConfig) {
-  if (!environmentConfig || typeof environmentConfig !== "object") return null;
-  const record = environmentConfig;
-  const baseUrl = typeof record.baseUrl === "string" ? record.baseUrl.trim() : "";
-  if (baseUrl) return baseUrl;
-  const domain = typeof record.domain === "string" ? record.domain.trim() : "";
-  if (!domain) return null;
-  return /^https?:\/\//u.test(domain) ? domain : `https://${domain}`;
-}
-function resolveSceneApiBaseUrl(input) {
-  if (input.environment === "local") {
-    const instance = readDevInstance({ cwd: input.projectRoot, surface: "api" });
-    const managedApi = httpHealthBaseUrl(instance);
-    if (managedApi) return managedApi;
-    const envApi = process.env.TREESEED_API_BASE_URL?.trim() || process.env.TREESEED_MARKET_API_BASE_URL?.trim();
-    if (envApi) return envApi.replace(/\/+$/u, "");
-    return input.webBaseUrl;
-  }
-  const environment = input.environment === "prod" ? "prod" : input.environment === "staging" ? "staging" : null;
-  if (!environment) return input.webBaseUrl;
-  const configured = configuredHostedApiBaseUrl(input.projectRoot, environment);
-  return configured ?? input.webBaseUrl;
-}
-function configuredHostedApiBaseUrl(projectRoot, environment) {
-  const candidates = [
-    resolve(projectRoot, "treeseed.site.yaml"),
-    resolve(projectRoot, "packages", "api", "treeseed.site.yaml"),
-    resolve(projectRoot, "..", "..", "treeseed.site.yaml"),
-    resolve(projectRoot, "..", "..", "packages", "api", "treeseed.site.yaml")
-  ];
-  for (const candidate of candidates) {
-    if (!existsSync(candidate)) continue;
-    try {
-      const config = loadDeployConfigFromPath(candidate);
-      const serviceUrl = hostedApiUrl(config.connections?.api?.environments?.[environment]) ?? hostedApiUrl(config.services?.api?.environments?.[environment]) ?? hostedApiUrl(config.surfaces?.api?.environments?.[environment]) ?? (environment === "prod" ? config.surfaces?.api?.publicBaseUrl : void 0);
-      if (typeof serviceUrl === "string" && serviceUrl.trim()) return serviceUrl.trim();
-    } catch {
-    }
-  }
-  if (environment === "prod") return "https://api.treeseed.dev";
-  if (environment === "staging") return "https://api.preview.treeseed.dev";
-  return null;
-}
-function hostedApiUrl(environmentConfig) {
-  return hostedWebUrl(environmentConfig);
-}
-function httpHealthBaseUrl(instance) {
-  const healthUrl = instance?.health?.find((entry) => entry.kind === "http" && typeof entry.url === "string")?.url;
-  if (!healthUrl) return null;
-  try {
-    const url = new URL(healthUrl);
-    if (url.hostname === "0.0.0.0") url.hostname = "127.0.0.1";
-    return url.origin;
-  } catch {
-    return healthUrl.replace(/\/healthz?$/u, "").replace(/\/+$/u, "");
-  }
-}
-export {
-  resolveSceneApiBaseUrl,
-  resolveSceneBaseUrl
-};

package/dist/scenes/support/execution/loader.d.ts

@@ -1,3 +0,0 @@
-import type { LoadedSceneDocument } from '../../types.js';
-export declare function resolveScenePath(projectRoot: string, sceneNameOrPath: string): string;
-export declare function loadSceneDocument(projectRoot: string, sceneNameOrPath: string): LoadedSceneDocument;

package/dist/scenes/support/execution/loader.js

@@ -1,38 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { isAbsolute, resolve } from "node:path";
-import { parseDocument } from "yaml";
-import { sceneErrorDiagnostic } from "../reporting/diagnostics.js";
-const FILESYSTEM_SAFE_SCENE_ID = /^[a-z0-9][a-z0-9._-]*$/u;
-function resolveScenePath(projectRoot, sceneNameOrPath) {
-  const value = sceneNameOrPath.trim();
-  if (/\.(?:ya?ml)$/iu.test(value)) {
-    return isAbsolute(value) ? value : resolve(projectRoot, value);
-  }
-  return resolve(projectRoot, "scenes", `${value}.yaml`);
-}
-function loadSceneDocument(projectRoot, sceneNameOrPath) {
-  const diagnostics = [];
-  const trimmed = sceneNameOrPath.trim();
-  const path = resolveScenePath(projectRoot, trimmed);
-  if (!/\.(?:ya?ml)$/iu.test(trimmed) && !FILESYSTEM_SAFE_SCENE_ID.test(trimmed)) {
-    diagnostics.push(sceneErrorDiagnostic("scene.invalid_name", `Scene name must be a simple file-safe identifier: ${sceneNameOrPath}.`, "scene"));
-    return { path, value: null, diagnostics };
-  }
-  if (!existsSync(path)) {
-    diagnostics.push(sceneErrorDiagnostic("scene.not_found", `Scene manifest not found at ${path}.`, "manifest"));
-    return { path, value: null, diagnostics };
-  }
-  const source = readFileSync(path, "utf8");
-  const document = parseDocument(source, { prettyErrors: false });
-  for (const parseError of document.errors) {
-    diagnostics.push(sceneErrorDiagnostic("scene.yaml_parse_error", parseError.message, "manifest"));
-  }
-  if (diagnostics.length > 0) {
-    return { path, value: null, diagnostics };
-  }
-  return { path, value: document.toJSON(), diagnostics };
-}
-export {
-  loadSceneDocument,
-  resolveScenePath
-};

package/dist/scenes/support/execution/phase0.d.ts

@@ -1,9 +0,0 @@
-import type { SceneArtifactPathPlan, ScenePhase0Report } from '../../types.js';
-export declare const SCENE_PLATFORM_NAME: "central TreeSeed acceptance test harness and demo / educational video generator";
-export declare function createScenePhase0Report(): ScenePhase0Report;
-export declare function planSceneArtifactPaths(input: {
-    workspaceRoot: string;
-    sceneId: string;
-    runId?: string;
-    timestamp?: string;
-}): SceneArtifactPathPlan;

package/dist/scenes/support/execution/phase0.js

@@ -1,103 +0,0 @@
-import { join } from "node:path";
-import { PHASE0_MEDIA_EVIDENCE_CAPABILITIES, PHASE0_PUBLICATION_AUDIT_CAPABILITIES, PHASE0_RUNTIME_CAPABILITIES } from "../plugins/phase0-capabilities.js";
-const SCENE_PLATFORM_NAME = "central TreeSeed acceptance test harness and demo / educational video generator";
-const PHASE0_COMMAND_SURFACE = [
-  "trsd scene",
-  "trsd scene status",
-  "trsd scene status --json",
-  "trsd scene validate <scene.yaml> --json",
-  "trsd scene plan <scene.yaml> --json",
-  "trsd scene run <scene.yaml> --environment local|staging|prod --record --json",
-  "trsd scene inspect <run-id-or-path> --step <step-id> --json",
-  "trsd scene resume <run-id-or-path> --from-checkpoint <checkpoint-id> --json",
-  "trsd scene render <scene.yaml> --from <run-id-or-path> --renderer remotion --format mp4 --json",
-  "trsd scene render <scene.yaml> --from <run-id-or-path> --mode diagram-only --json",
-  "trsd scene training <scene.yaml> --from <run-id-or-path> --format json|markdown|vtt|srt --json",
-  "trsd scene evidence <scene.yaml> --from <run-id-or-path> --target local|ci|release --bundle metadata-only|sanitized --json",
-  "trsd scene publish <scene.yaml> --from <run-id-or-path> --target local|release --redaction-policy <path> --json",
-  "trsd scene publish-plan <scene.yaml> --from <run-id-or-path> --target docs,training,release-evidence,artifact-store --json",
-  "trsd scene export <scene.yaml> --from <run-id-or-path> --target docs,training,release-evidence,artifact-store --json",
-  "trsd scene visual-audit <scene.yaml> --roles anonymous,owner,admin,member --device desktop|tablet|mobile|all --path-root /app,/auth,/market --path /app/projects/** --exclude-path **/delete --json"
-];
-const PHASE0_SDK_EXPORTS = [
-  "@treeseed/sdk/scenes",
-  "createTreeseedScenePhase0Report",
-  "planTreeseedSceneArtifactPaths",
-  "generateTreeseedSceneTrainingOutputs",
-  "buildTreeseedSceneTrainingOutputs",
-  "generateTreeseedSceneEvidence",
-  "buildTreeseedSceneEvidenceManifest",
-  "writeTreeseedSceneEvidence",
-  "publishTreeseedSceneEvidence",
-  "buildTreeseedScenePublishManifest",
-  "createDefaultTreeseedSceneRedactionPolicy",
-  "planTreeseedScenePublication",
-  "exportTreeseedScenePublication",
-  "buildTreeseedScenePublishPlanManifest",
-  "runTreeseedSceneVisualAudit",
-  "discoverTreeseedSceneVisualAuditRoutes"
-];
-const FILESYSTEM_SAFE_SCENE_ID = /^[a-z0-9][a-z0-9._-]*$/u;
-function compactTimestamp(date = /* @__PURE__ */ new Date()) {
-  return date.toISOString().replace(/[-:.]/gu, "");
-}
-function defaultRunId(timestamp) {
-  return timestamp.toLowerCase().replace(/[^a-z0-9]/gu, "").slice(0, 20) || "phase0run";
-}
-function createScenePhase0Report() {
-  return {
-    ok: true,
-    phase: 0,
-    status: "foundation_ready",
-    name: SCENE_PLATFORM_NAME,
-    commandSurface: [...PHASE0_COMMAND_SURFACE],
-    sdkExports: [...PHASE0_SDK_EXPORTS],
-    capabilities: [...PHASE0_RUNTIME_CAPABILITIES, ...PHASE0_MEDIA_EVIDENCE_CAPABILITIES, ...PHASE0_PUBLICATION_AUDIT_CAPABILITIES],
-    deferredDependencies: [],
-    activeOptionalDependencies: ["remotion", "@remotion/renderer", "@remotion/bundler"],
-    nextPhase: {
-      phase: 12,
-      summary: "Remote Publication Apply",
-      requiredChanges: [
-        "Apply Phase 11 publication intents through canonical reconciliation adapters.",
-        "Add provider-backed docs, training, and artifact-store publication once remote retention and redaction policy are finalized."
-      ]
-    }
-  };
-}
-function planSceneArtifactPaths(input) {
-  const sceneId = input.sceneId.trim();
-  if (!FILESYSTEM_SAFE_SCENE_ID.test(sceneId)) {
-    throw new Error(`Invalid scene id "${input.sceneId}". Use lowercase letters, numbers, dots, underscores, or hyphens, and start with a letter or number.`);
-  }
-  const timestamp = input.timestamp ?? compactTimestamp();
-  const runId = input.runId ?? defaultRunId(timestamp);
-  const runRoot = join(input.workspaceRoot, ".treeseed", "scenes", "runs", sceneId, `${timestamp}-${runId}`);
-  return {
-    workspaceRoot: input.workspaceRoot,
-    sceneId,
-    runId,
-    runRoot,
-    normalizedScenePath: join(runRoot, "scene.normalized.json"),
-    planPath: join(runRoot, "scene.plan.json"),
-    runPath: join(runRoot, "run.json"),
-    timelinePath: join(runRoot, "timeline.json"),
-    markdownReportPath: join(runRoot, "report.md"),
-    htmlReportPath: join(runRoot, "report.html"),
-    playwrightRoot: join(runRoot, "playwright"),
-    logsRoot: join(runRoot, "logs"),
-    segmentsRoot: join(runRoot, "segments"),
-    renderRoot: join(runRoot, "render"),
-    trainingRoot: join(runRoot, "training"),
-    evidenceRoot: join(runRoot, "evidence"),
-    publishRoot: join(runRoot, "publish"),
-    publishPlanRoot: join(runRoot, "publish-plan"),
-    progressPath: join(runRoot, "progress.jsonl"),
-    checkpointsRoot: join(runRoot, "checkpoints")
-  };
-}
-export {
-  SCENE_PLATFORM_NAME,
-  createScenePhase0Report,
-  planSceneArtifactPaths
-};

package/dist/scenes/support/execution/planner.d.ts

@@ -1,12 +0,0 @@
-import { type SceneEnvironment, type ScenePlanReport, type SceneValidationReport } from '../../types.js';
-export declare function validateScene(input: {
-    projectRoot: string;
-    scene: string;
-}): SceneValidationReport;
-export declare function planScene(input: {
-    projectRoot: string;
-    scene: string;
-    environment?: SceneEnvironment;
-    runId?: string;
-    timestamp?: string;
-}): ScenePlanReport;

package/dist/scenes/support/execution/planner.js

@@ -1,166 +0,0 @@
-import {
-  SCENE_ENVIRONMENTS
-} from "../../types.js";
-import {
-  listBuiltInSceneActions,
-  listBuiltInSceneAssertions,
-  listBuiltInSceneRenderers,
-  resolveScenePlugins
-} from "../plugins/registry.js";
-import { SceneDiagramPluginId, validateSceneDiagrams } from "../rendering/diagram-validation.js";
-import { hasSceneErrors, sceneErrorDiagnostic } from "../reporting/diagnostics.js";
-import { parseSceneManifest, sceneActionKind, sceneExpectationKinds } from "../validation/schema.js";
-import { loadSceneDocument } from "./loader.js";
-import { planSceneArtifactPaths } from "./phase0.js";
-function splitDiagnostics(diagnostics, severity) {
-  return diagnostics.filter((diagnostic) => diagnostic.severity === severity);
-}
-function resolveEnvironment(value, fallback) {
-  return value ?? fallback;
-}
-function chapterForStep(stepId, chapters) {
-  let current = null;
-  for (const chapter of chapters) {
-    if (chapter.startsAt === stepId) current = chapter.id;
-  }
-  return current;
-}
-function rendererIds(scene) {
-  return [
-    ...scene.render.remotion ? ["remotion"] : [],
-    ...scene.overlays.map((overlay) => overlay.renderer),
-    ...scene.diagrams.map((diagram) => diagram.renderer)
-  ].filter(Boolean);
-}
-function trainingOutputIds(scene) {
-  if (!scene.training.enabled) return [];
-  return [
-    ...scene.training.captions.enabled ? ["captions"] : [],
-    ...scene.training.transcript.enabled ? ["transcript"] : [],
-    ...scene.training.narration.enabled ? ["narration"] : [],
-    ...scene.training.glossary.enabled ? ["glossary"] : [],
-    ...scene.training.chapterClips.enabled ? ["chapter-clips"] : []
-  ];
-}
-function enabledPluginIds(input) {
-  return [.../* @__PURE__ */ new Set([
-    ...input.actionIds.map((id) => input.registry.actionPlugins.get(id)).filter((id) => Boolean(id)),
-    ...input.assertionIds.map((id) => input.registry.assertionPlugins.get(id)).filter((id) => Boolean(id)),
-    ...input.rendererIds.map((id) => input.registry.rendererPlugins.get(id)).filter((id) => Boolean(id)),
-    ...(input.diagramIds ?? []).map((id) => SceneDiagramPluginId({ component: id, registry: input.registry })).filter((id) => Boolean(id)),
-    ...(input.trainingOutputIds ?? []).length > 0 ? ["treeseed.scene.training.deterministic"] : []
-  ])].sort();
-}
-function validateScene(input) {
-  const loaded = loadSceneDocument(input.projectRoot, input.scene);
-  const diagnostics = [...loaded.diagnostics];
-  const scene = diagnostics.length > 0 ? null : parseSceneManifest(loaded.value, diagnostics);
-  return {
-    ok: scene !== null && !hasSceneErrors(diagnostics),
-    scenePath: loaded.path,
-    scene: scene && !hasSceneErrors(diagnostics) ? scene : null,
-    diagnostics
-  };
-}
-function planScene(input) {
-  const validation = validateScene(input);
-  const pluginResolution = resolveScenePlugins();
-  const diagnostics = [...validation.diagnostics];
-  const scene = validation.scene;
-  const diagramDiagnostics = scene ? validateSceneDiagrams({ scene, registry: pluginResolution.registry }) : [];
-  if (input.environment && !SCENE_ENVIRONMENTS.includes(input.environment)) {
-    diagnostics.push(sceneErrorDiagnostic("scene.invalid_environment", `Unknown environment: ${input.environment}.`, "environment"));
-  }
-  const environment = resolveEnvironment(input.environment, scene?.target.environment ?? "local");
-  const combinedDiagnostics = [...diagnostics, ...diagramDiagnostics, ...pluginResolution.diagnostics];
-  const blockers = splitDiagnostics(combinedDiagnostics, "error");
-  const warnings = splitDiagnostics(combinedDiagnostics, "warning");
-  if (!scene || blockers.length > 0) {
-    const allActionIds = listBuiltInSceneActions().map((action) => action.id);
-    const allAssertionIds = listBuiltInSceneAssertions().map((assertion) => assertion.id);
-    const allRendererIds = listBuiltInSceneRenderers().map((renderer) => renderer.id);
-    return {
-      ok: false,
-      phase: 1,
-      scenePath: validation.scenePath,
-      sceneId: scene?.id ?? null,
-      title: scene?.title ?? null,
-      environment,
-      baseUrl: scene?.target.baseUrl ?? "auto",
-      browser: scene?.target.browser ?? null,
-      viewport: scene?.target.viewport ?? null,
-      workflowSteps: [],
-      enabledActions: allActionIds,
-      enabledAssertions: allAssertionIds,
-      enabledRenderers: allRendererIds,
-      enabledDiagrams: scene?.diagrams.map((diagram) => diagram.component).sort() ?? [],
-      enabledDiagramPlugins: scene ? [...new Set(scene.diagrams.map((diagram) => SceneDiagramPluginId({ component: diagram.component, registry: pluginResolution.registry })).filter((id) => Boolean(id)))].sort() : [],
-      enabledTrainingOutputs: scene ? trainingOutputIds(scene) : [],
-      enabledNarrationPlugins: scene?.training.enabled && scene.training.narration.enabled ? ["treeseed.scene.training.deterministic"] : [],
-      enabledDeviceProfiles: scene?.devices.profiles.map((profile) => profile.id).sort() ?? [],
-      enabledPlugins: enabledPluginIds({ actionIds: allActionIds, assertionIds: allAssertionIds, rendererIds: allRendererIds, diagramIds: scene?.diagrams.map((diagram) => diagram.component) ?? [], trainingOutputIds: scene ? trainingOutputIds(scene) : [], registry: pluginResolution.registry }),
-      plugins: pluginResolution.summaries,
-      pluginDiagnostics: pluginResolution.diagnostics,
-      artifactPaths: null,
-      diagnostics: combinedDiagnostics,
-      warnings,
-      blockers,
-      estimatedDurationSeconds: null
-    };
-  }
-  let currentChapter = null;
-  const workflowSteps = scene.workflow.map((step) => {
-    currentChapter = chapterForStep(step.id, scene.chapters) ?? currentChapter;
-    return {
-      id: step.id,
-      title: step.title,
-      actionKind: sceneActionKind(step.action),
-      assertionKinds: sceneExpectationKinds(step.expect),
-      chapterId: currentChapter,
-      demoOnly: step.demoOnly === true
-    };
-  });
-  const actionIds = [...new Set(workflowSteps.map((step) => step.actionKind))];
-  const assertionIds = [...new Set(workflowSteps.flatMap((step) => step.assertionKinds))];
-  const activeRendererIds = [...new Set(rendererIds(scene))];
-  const diagramIds = [...new Set(scene.diagrams.map((diagram) => diagram.component))].sort();
-  const diagramPluginIds = [...new Set(diagramIds.map((id) => SceneDiagramPluginId({ component: id, registry: pluginResolution.registry })).filter((id) => Boolean(id)))].sort();
-  const trainingOutputs = trainingOutputIds(scene);
-  return {
-    ok: true,
-    phase: 1,
-    scenePath: validation.scenePath,
-    sceneId: scene.id,
-    title: scene.title,
-    environment,
-    baseUrl: scene.target.baseUrl,
-    browser: scene.target.browser,
-    viewport: scene.target.viewport,
-    workflowSteps,
-    enabledActions: actionIds,
-    enabledAssertions: assertionIds,
-    enabledRenderers: activeRendererIds,
-    enabledDiagrams: diagramIds,
-    enabledDiagramPlugins: diagramPluginIds,
-    enabledTrainingOutputs: trainingOutputs,
-    enabledNarrationPlugins: scene.training.enabled && scene.training.narration.enabled ? ["treeseed.scene.training.deterministic"] : [],
-    enabledDeviceProfiles: scene.devices.profiles.map((profile) => profile.id).sort(),
-    enabledPlugins: enabledPluginIds({ actionIds, assertionIds, rendererIds: activeRendererIds, diagramIds, trainingOutputIds: trainingOutputs, registry: pluginResolution.registry }),
-    plugins: pluginResolution.summaries,
-    pluginDiagnostics: pluginResolution.diagnostics,
-    artifactPaths: planSceneArtifactPaths({
-      workspaceRoot: input.projectRoot,
-      sceneId: scene.id,
-      runId: input.runId,
-      timestamp: input.timestamp
-    }),
-    diagnostics: combinedDiagnostics,
-    warnings,
-    blockers,
-    estimatedDurationSeconds: null
-  };
-}
-export {
-  planScene,
-  validateScene
-};

package/dist/scenes/support/execution/resume.d.ts

@@ -1,2 +0,0 @@
-import type { SceneResumeOptions, SceneRunReport } from '../../types.js';
-export declare function resumeScene(input: SceneResumeOptions): Promise<SceneRunReport>;

package/dist/scenes/support/execution/resume.js

@@ -1,82 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { runScene } from "../../operations/runner.js";
-import { sceneErrorDiagnostic } from "../reporting/diagnostics.js";
-import { resolveSceneRunRoot } from "../reporting/inspect.js";
-function readJson(path) {
-  return JSON.parse(readFileSync(path, "utf8"));
-}
-function blocked(input, diagnostics) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  return {
-    ok: false,
-    phase: 5,
-    sceneId: null,
-    runId: null,
-    scenePath: input.run,
-    startedAt: now,
-    finishedAt: now,
-    durationMs: 0,
-    environment: input.environment ?? "local",
-    baseUrl: null,
-    browser: null,
-    workflowStatus: "blocked",
-    steps: [],
-    failedStep: null,
-    assertions: [],
-    artifacts: null,
-    timelinePath: null,
-    playwrightTracePath: null,
-    videoPaths: [],
-    renderedVideoPaths: [],
-    logs: {},
-    setup: null,
-    operations: [],
-    chapters: [],
-    segments: [],
-    checkpoints: [],
-    resumedFrom: null,
-    progressPath: null,
-    warnings: diagnostics.filter((entry) => entry.severity === "warning"),
-    blockers: diagnostics.filter((entry) => entry.severity === "error"),
-    diagnostics
-  };
-}
-async function resumeScene(input) {
-  input.onProgress?.({ type: "resume.started", sceneId: null, runId: null, timestamp: (/* @__PURE__ */ new Date()).toISOString(), offsetMs: 0, checkpointId: input.fromCheckpoint, data: { run: input.run } });
-  const resolved = resolveSceneRunRoot(input.projectRoot, input.run);
-  if (!resolved.runRoot) return blocked(input, resolved.diagnostics);
-  const checkpointPath = join(resolved.runRoot, "checkpoints", `${input.fromCheckpoint}.json`);
-  if (!existsSync(checkpointPath)) return blocked(input, [sceneErrorDiagnostic("scene.checkpoint_not_found", `Checkpoint not found: ${input.fromCheckpoint}.`, "checkpoint")]);
-  const checkpoint = readJson(checkpointPath);
-  if (!checkpoint.resumable) return blocked(input, [sceneErrorDiagnostic("scene.checkpoint_not_resumable", `Checkpoint is not resumable: ${input.fromCheckpoint}.`, "checkpoint")]);
-  const scenePath = join(resolved.runRoot, "scene.normalized.json");
-  if (!existsSync(scenePath)) return blocked(input, [sceneErrorDiagnostic("scene.normalized_scene_not_found", `Normalized scene not found: ${scenePath}.`, "scene")]);
-  const scene = readJson(scenePath);
-  const nextIndex = checkpoint.nextStepId ? scene.workflow.findIndex((step) => step.id === checkpoint.nextStepId) : scene.workflow.length;
-  if (nextIndex < 0) return blocked(input, [sceneErrorDiagnostic("scene.resume_step_not_found", `Resume step not found: ${checkpoint.nextStepId}.`, "checkpoint.nextStepId")]);
-  const resumeScene2 = {
-    ...scene,
-    workflow: scene.workflow.slice(nextIndex)
-  };
-  const storageStatePath = checkpointPath.replace(/\.json$/u, ".storage.json");
-  const report = await runScene({
-    ...input,
-    runId: checkpoint.runId,
-    scene: resumeScene2,
-    ...existsSync(storageStatePath) ? { inputStorageStatePath: storageStatePath } : {},
-    onProgress: (event) => {
-      input.onProgress?.(event);
-    }
-  });
-  report.resumedFrom = {
-    runRoot: resolved.runRoot,
-    checkpointId: checkpoint.id,
-    sourceRunId: checkpoint.runId
-  };
-  input.onProgress?.({ type: "resume.finished", sceneId: report.sceneId, runId: report.runId, timestamp: (/* @__PURE__ */ new Date()).toISOString(), offsetMs: 0, checkpointId: checkpoint.id, status: report.workflowStatus, data: { ok: report.ok } });
-  return report;
-}
-export {
-  resumeScene
-};

package/dist/scenes/support/execution/timeouts.d.ts

@@ -1,7 +0,0 @@
-import type { SceneDiagnostic, SceneWorkflowStep } from '../../types.js';
-export declare function resolveSceneStepTimeoutSeconds(step: SceneWorkflowStep, defaultSeconds: number): number;
-export declare function withSceneTimeout<T>(input: {
-    promise: Promise<T>;
-    timeoutMs: number | null;
-    diagnostic: SceneDiagnostic;
-}): Promise<T>;

package/dist/scenes/support/execution/timeouts.js

@@ -1,26 +0,0 @@
-function actionTimeoutFloorSeconds(action) {
-  if (!("waitForOperation" in action) || !action.waitForOperation.timeoutSeconds) return 0;
-  const pollingGrace = Math.max(1, action.waitForOperation.pollIntervalSeconds ?? 2);
-  return action.waitForOperation.timeoutSeconds + pollingGrace;
-}
-function resolveSceneStepTimeoutSeconds(step, defaultSeconds) {
-  return Math.max(step.timeoutSeconds ?? defaultSeconds, actionTimeoutFloorSeconds(step.action));
-}
-async function withSceneTimeout(input) {
-  if (!input.timeoutMs || input.timeoutMs <= 0) return input.promise;
-  let timeout;
-  try {
-    return await Promise.race([
-      input.promise,
-      new Promise((_, reject) => {
-        timeout = setTimeout(() => reject(input.diagnostic), input.timeoutMs);
-      })
-    ]);
-  } finally {
-    if (timeout) clearTimeout(timeout);
-  }
-}
-export {
-  resolveSceneStepTimeoutSeconds,
-  withSceneTimeout
-};

package/dist/scenes/support/plugins/builtin-plugins.d.ts

@@ -1,2 +0,0 @@
-export * from '../../builtin-plugins/create-built-in-scene-plugins.js';
-export * from '../../builtin-plugins/duration.js';

package/dist/scenes/support/plugins/builtin-plugins.js

@@ -1,2 +0,0 @@
-export * from "../../builtin-plugins/create-built-in-scene-plugins.js";
-export * from "../../builtin-plugins/duration.js";

package/dist/scenes/support/plugins/phase0-capabilities.d.ts

@@ -1,3 +0,0 @@
-export { PHASE0_RUNTIME_CAPABILITIES } from '../../runtime/phase0-runtime-capabilities.js';
-export { PHASE0_MEDIA_EVIDENCE_CAPABILITIES } from '../rendering/phase0-media-evidence-capabilities.js';
-export { PHASE0_PUBLICATION_AUDIT_CAPABILITIES } from './phase0-publication-audit-capabilities.js';

package/dist/scenes/support/plugins/phase0-capabilities.js

@@ -1,8 +0,0 @@
-import { PHASE0_RUNTIME_CAPABILITIES } from "../../runtime/phase0-runtime-capabilities.js";
-import { PHASE0_MEDIA_EVIDENCE_CAPABILITIES } from "../rendering/phase0-media-evidence-capabilities.js";
-import { PHASE0_PUBLICATION_AUDIT_CAPABILITIES } from "./phase0-publication-audit-capabilities.js";
-export {
-  PHASE0_MEDIA_EVIDENCE_CAPABILITIES,
-  PHASE0_PUBLICATION_AUDIT_CAPABILITIES,
-  PHASE0_RUNTIME_CAPABILITIES
-};