@treeseed/sdk 0.13.0-rc.8 → 0.13.0-rc.80

package/dist/scenes/schema/parse-action.js

@@ -1,288 +0,0 @@
-import { findBuiltInSceneAction, findBuiltInSceneAssertion } from "../support/plugins/registry.js";
-import { sceneErrorDiagnostic, sceneWarningDiagnostic } from "../support/reporting/diagnostics.js";
-import { DEVICE_BROWSER_CHROME, DEVICE_ORIENTATIONS, FILESYSTEM_SAFE_SCENE_ID, arrayField, asString, booleanField, isRecord, objectField, optionalString, parseBrowser, parseEnvironment, parseSelector, positiveNumberField, requireString, stringArrayField } from "./filesystem-safe-scene-id.js";
-function parseAction(value, path, diagnostics) {
-  if (!isRecord(value)) {
-    diagnostics.push(sceneErrorDiagnostic("scene.invalid_action", "Expected action to be an object.", path));
-    return null;
-  }
-  const keys = Object.keys(value).filter((key2) => value[key2] !== void 0);
-  const supported = keys.filter((key2) => findBuiltInSceneAction(key2));
-  if (keys.length !== 1 || supported.length !== 1) {
-    diagnostics.push(sceneErrorDiagnostic("scene.invalid_action", `Expected exactly one supported action key. Supported actions: goto, click, clickVisibleSequence, fill, select, keyboard, browserHistory, pause, mailpitConfirmLatest, apiRequest, waitForOperation.`, path));
-    return null;
-  }
-  const key = supported[0];
-  if (key === "goto") {
-    if (!isRecord(value.goto)) return { goto: asString(value.goto) || "" };
-    const route = requireString(value.goto, "path", `${path}.goto`, diagnostics);
-    const expectedStatus = Number(value.goto.expectedStatus);
-    if (!Number.isInteger(expectedStatus) || expectedStatus < 100 || expectedStatus > 599) {
-      diagnostics.push(sceneErrorDiagnostic("scene.invalid_navigation_status", "goto.expectedStatus must be an HTTP status from 100 through 599.", `${path}.goto.expectedStatus`));
-    }
-    return { goto: { path: route, expectedStatus } };
-  }
-  if (key === "keyboard") return { keyboard: asString(value.keyboard) || "" };
-  if (key === "browserHistory") {
-    const direction = asString(value.browserHistory);
-    if (direction !== "back" && direction !== "forward") diagnostics.push(sceneErrorDiagnostic("scene.invalid_browser_history", "browserHistory must be back or forward.", `${path}.browserHistory`));
-    return { browserHistory: direction === "forward" ? "forward" : "back" };
-  }
-  if (key === "apiRequest") return { apiRequest: isRecord(value.apiRequest) ? value.apiRequest : {} };
-  if (key === "waitForOperation") {
-    const operation = isRecord(value.waitForOperation) ? value.waitForOperation : {};
-    const status = stringArrayField(operation, "status", `${path}.waitForOperation`, diagnostics);
-    return {
-      waitForOperation: {
-        ...optionalString(operation, "id") ? { id: optionalString(operation, "id") } : {},
-        ...optionalString(operation, "kind") ? { kind: optionalString(operation, "kind") } : {},
-        status,
-        timeoutSeconds: positiveNumberField(operation, "timeoutSeconds", void 0, `${path}.waitForOperation`, diagnostics),
-        pollIntervalSeconds: positiveNumberField(operation, "pollIntervalSeconds", void 0, `${path}.waitForOperation`, diagnostics),
-        ...asString(operation.source) ? { source: asString(operation.source) } : {}
-      }
-    };
-  }
-  if (key === "pause") {
-    const pause = isRecord(value.pause) ? value.pause : {};
-    const mode = asString(pause.mode) === "timed" ? "timed" : "manual";
-    const durationSeconds = positiveNumberField(pause, "durationSeconds", void 0, `${path}.pause`, diagnostics);
-    if (mode === "timed" && durationSeconds === void 0) diagnostics.push(sceneErrorDiagnostic("scene.missing_field", "Timed pause actions must define durationSeconds.", `${path}.pause.durationSeconds`));
-    return { pause: { mode, ...optionalString(pause, "prompt") ? { prompt: optionalString(pause, "prompt") } : {}, ...durationSeconds ? { durationSeconds } : {} } };
-  }
-  if (key === "mailpitConfirmLatest") {
-    const spec = isRecord(value.mailpitConfirmLatest) ? value.mailpitConfirmLatest : {};
-    return {
-      mailpitConfirmLatest: {
-        mailpitUrl: requireString(spec, "mailpitUrl", `${path}.mailpitConfirmLatest`, diagnostics),
-        email: requireString(spec, "email", `${path}.mailpitConfirmLatest`, diagnostics),
-        ...optionalString(spec, "subjectIncludes") ? { subjectIncludes: optionalString(spec, "subjectIncludes") } : {},
-        ...spec.displayInboxSeconds !== void 0 ? { displayInboxSeconds: positiveNumberField(spec, "displayInboxSeconds", void 0, `${path}.mailpitConfirmLatest`, diagnostics) } : {},
-        ...spec.displayMessageSeconds !== void 0 ? { displayMessageSeconds: positiveNumberField(spec, "displayMessageSeconds", void 0, `${path}.mailpitConfirmLatest`, diagnostics) } : {},
-        ...typeof spec.navigate === "boolean" ? { navigate: spec.navigate } : {}
-      }
-    };
-  }
-  if (key === "click") {
-    const selector2 = parseSelector(value.click, `${path}.click`, diagnostics);
-    return selector2 ? { click: selector2 } : null;
-  }
-  if (key === "clickVisibleSequence") {
-    const entries = arrayField(value, "clickVisibleSequence", path, diagnostics) ?? [];
-    const selectors = entries.map((entry, index) => parseSelector(entry, `${path}.clickVisibleSequence[${index}]`, diagnostics)).filter((entry) => Boolean(entry));
-    if (selectors.length === 0) diagnostics.push(sceneErrorDiagnostic("scene.missing_field", "clickVisibleSequence requires at least one selector.", `${path}.clickVisibleSequence`));
-    return { clickVisibleSequence: selectors };
-  }
-  if (key === "select") {
-    const selectValue = isRecord(value.select) ? value.select : {};
-    const selector2 = parseSelector(selectValue, `${path}.select`, diagnostics);
-    const optionValue = asString(selectValue.value);
-    const optionLabel = asString(selectValue.label);
-    if (!optionValue && !optionLabel) diagnostics.push(sceneErrorDiagnostic("scene.missing_field", "Select actions must define value or label.", `${path}.select.value`));
-    return selector2 ? { select: { ...selector2, ...optionValue ? { value: optionValue } : {}, ...optionLabel ? { label: optionLabel } : {} } } : null;
-  }
-  const fillValue = isRecord(value.fill) ? value.fill : {};
-  const selector = parseSelector(fillValue, `${path}.fill`, diagnostics);
-  const fillText = asString(fillValue.value);
-  if (!fillText) diagnostics.push(sceneErrorDiagnostic("scene.missing_field", "Missing required field: value.", `${path}.fill.value`));
-  return selector ? { fill: { ...selector, value: fillText } } : null;
-}
-function parseExpectation(value, path, diagnostics) {
-  if (value === void 0) return void 0;
-  if (!isRecord(value)) {
-    diagnostics.push(sceneErrorDiagnostic("scene.invalid_expectation", "Expected expect to be an object.", path));
-    return void 0;
-  }
-  const expectation = {};
-  for (const key of Object.keys(value)) {
-    if (!findBuiltInSceneAssertion(key)) {
-      diagnostics.push(sceneWarningDiagnostic("scene.unknown_expectation", `Unknown expectation key: ${key}.`, `${path}.${key}`));
-    }
-  }
-  if (value.visible !== void 0) {
-    const visible = arrayField(value, "visible", path, diagnostics) ?? [];
-    expectation.visible = visible.map((entry, index) => parseSelector(entry, `${path}.visible[${index}]`, diagnostics)).filter((entry) => Boolean(entry));
-  }
-  if (value.notVisible !== void 0) {
-    const notVisible = arrayField(value, "notVisible", path, diagnostics) ?? [];
-    expectation.notVisible = notVisible.map((entry, index) => parseSelector(entry, `${path}.notVisible[${index}]`, diagnostics)).filter((entry) => Boolean(entry));
-  }
-  if (value.focused !== void 0) {
-    const focused = parseSelector(value.focused, `${path}.focused`, diagnostics);
-    if (focused) expectation.focused = focused;
-  }
-  if (value.text !== void 0) expectation.text = asString(value.text);
-  if (value.notText !== void 0) expectation.notText = asString(value.notText);
-  if (value.urlIncludes !== void 0) expectation.urlIncludes = asString(value.urlIncludes);
-  if (value.operation !== void 0) {
-    if (!isRecord(value.operation)) {
-      diagnostics.push(sceneErrorDiagnostic("scene.invalid_operation_expectation", "Expected operation expectation to be an object.", `${path}.operation`));
-    } else {
-      expectation.operation = {
-        ...optionalString(value.operation, "id") ? { id: optionalString(value.operation, "id") } : {},
-        kind: requireString(value.operation, "kind", `${path}.operation`, diagnostics),
-        status: stringArrayField(value.operation, "status", `${path}.operation`, diagnostics),
-        timeoutSeconds: positiveNumberField(value.operation, "timeoutSeconds", void 0, `${path}.operation`, diagnostics),
-        pollIntervalSeconds: positiveNumberField(value.operation, "pollIntervalSeconds", void 0, `${path}.operation`, diagnostics),
-        ...asString(value.operation.source) ? { source: asString(value.operation.source) } : {}
-      };
-    }
-  }
-  return expectation;
-}
-function expectationKeys(expectation) {
-  if (!expectation) return [];
-  return ["visible", "notVisible", "focused", "text", "notText", "urlIncludes", "operation"].filter((key) => expectation[key] !== void 0);
-}
-function actionCanOmitExpectation(action) {
-  return Boolean(action && ("fill" in action || "select" in action || "keyboard" in action));
-}
-function parseMode(value, diagnostics) {
-  const record = isRecord(value) ? value : {};
-  return {
-    test: booleanField(record, "test", true, "mode", diagnostics),
-    demo: booleanField(record, "demo", false, "mode", diagnostics),
-    training: booleanField(record, "training", false, "mode", diagnostics)
-  };
-}
-function parseTarget(value, diagnostics) {
-  const record = isRecord(value) ? value : {};
-  if (!isRecord(value)) diagnostics.push(sceneErrorDiagnostic("scene.missing_field", "Missing required field: target.", "target"));
-  const viewport = isRecord(record.viewport) ? record.viewport : {};
-  return {
-    app: requireString(record, "app", "target", diagnostics),
-    environment: parseEnvironment(record.environment, "target.environment", diagnostics, "local"),
-    baseUrl: asString(record.baseUrl) || "auto",
-    viewport: {
-      width: positiveNumberField(viewport, "width", 1440, "target.viewport", diagnostics) ?? 1440,
-      height: positiveNumberField(viewport, "height", 1e3, "target.viewport", diagnostics) ?? 1e3
-    },
-    browser: parseBrowser(record.browser, "target.browser", diagnostics)
-  };
-}
-function parseDimensionPair(value, path, diagnostics, defaults) {
-  const record = isRecord(value) ? value : {};
-  if (value !== void 0 && !isRecord(value)) diagnostics.push(sceneErrorDiagnostic("scene.invalid_object", `Expected ${path} to be an object.`, path));
-  return {
-    width: positiveNumberField(record, "width", defaults.width, path, diagnostics) ?? defaults.width,
-    height: positiveNumberField(record, "height", defaults.height, path, diagnostics) ?? defaults.height
-  };
-}
-function defaultSceneDeviceConfig() {
-  return {
-    defaultProfile: "desktop",
-    profiles: [
-      {
-        id: "desktop",
-        title: "Desktop",
-        orientation: "landscape",
-        viewport: { width: 1600, height: 900 },
-        video: { width: 1600, height: 900 },
-        output: { width: 1920, height: 1080 },
-        deviceScaleFactor: 1,
-        isMobile: false,
-        hasTouch: false
-      }
-    ]
-  };
-}
-function parseDevices(value, target, diagnostics) {
-  const defaults = defaultSceneDeviceConfig();
-  if (value === void 0) return defaults;
-  if (!isRecord(value)) {
-    diagnostics.push(sceneErrorDiagnostic("scene.invalid_object", "Expected devices to be an object.", "devices"));
-    return defaults;
-  }
-  for (const key of Object.keys(value)) {
-    if (!["defaultProfile", "profiles"].includes(key)) diagnostics.push(sceneWarningDiagnostic("scene.unknown_device_field", `Unknown devices field: ${key}.`, `devices.${key}`));
-  }
-  const entries = arrayField(value, "profiles", "devices", diagnostics) ?? [];
-  const profiles = [];
-  const seen = /* @__PURE__ */ new Set();
-  entries.forEach((entry, index) => {
-    const path = `devices.profiles[${index}]`;
-    if (!isRecord(entry)) {
-      diagnostics.push(sceneErrorDiagnostic("scene.invalid_device_profile", "Expected device profile to be an object.", path));
-      return;
-    }
-    for (const key of Object.keys(entry)) {
-      if (!["id", "title", "orientation", "viewport", "video", "output", "userAgent", "deviceScaleFactor", "isMobile", "hasTouch", "browserFrame"].includes(key)) diagnostics.push(sceneWarningDiagnostic("scene.unknown_device_field", `Unknown device profile field: ${key}.`, `${path}.${key}`));
-    }
-    const id = requireString(entry, "id", path, diagnostics);
-    if (id && !FILESYSTEM_SAFE_SCENE_ID.test(id)) diagnostics.push(sceneErrorDiagnostic("scene.invalid_id", `Invalid device profile id: ${id}.`, `${path}.id`));
-    if (id && seen.has(id)) diagnostics.push(sceneErrorDiagnostic("scene.device_duplicate", `Duplicate device profile id: ${id}.`, `${path}.id`));
-    seen.add(id);
-    const orientationValue = optionalString(entry, "orientation");
-    const orientation = orientationValue && DEVICE_ORIENTATIONS.includes(orientationValue) ? orientationValue : void 0;
-    if (orientationValue && !orientation) diagnostics.push(sceneErrorDiagnostic("scene.device_orientation_invalid", `Unknown device orientation: ${orientationValue}.`, `${path}.orientation`));
-    const browserFrame = objectField(entry, "browserFrame", path, diagnostics);
-    const chromeValue = browserFrame ? optionalString(browserFrame, "chrome") : void 0;
-    const chrome = chromeValue && DEVICE_BROWSER_CHROME.includes(chromeValue) ? chromeValue : void 0;
-    if (chromeValue && !chrome) diagnostics.push(sceneErrorDiagnostic("scene.device_browser_chrome_invalid", `Unknown browser frame chrome: ${chromeValue}.`, `${path}.browserFrame.chrome`));
-    const profile = {
-      id,
-      ...optionalString(entry, "title") ? { title: optionalString(entry, "title") } : {},
-      ...orientation ? { orientation } : {},
-      viewport: parseDimensionPair(entry.viewport, `${path}.viewport`, diagnostics, target.viewport),
-      ...entry.video !== void 0 ? { video: parseDimensionPair(entry.video, `${path}.video`, diagnostics, target.viewport) } : {},
-      ...entry.output !== void 0 ? { output: parseDimensionPair(entry.output, `${path}.output`, diagnostics, { width: 1920, height: 1080 }) } : {},
-      ...optionalString(entry, "userAgent") ? { userAgent: optionalString(entry, "userAgent") } : {},
-      ...entry.deviceScaleFactor !== void 0 ? { deviceScaleFactor: positiveNumberField(entry, "deviceScaleFactor", 1, path, diagnostics) ?? 1 } : {},
-      ...entry.isMobile !== void 0 ? { isMobile: booleanField(entry, "isMobile", false, path, diagnostics) } : {},
-      ...entry.hasTouch !== void 0 ? { hasTouch: booleanField(entry, "hasTouch", false, path, diagnostics) } : {},
-      ...browserFrame ? { browserFrame: { enabled: booleanField(browserFrame, "enabled", false, `${path}.browserFrame`, diagnostics), ...optionalString(browserFrame, "title") ? { title: optionalString(browserFrame, "title") } : {}, ...chrome ? { chrome } : {} } } : {}
-    };
-    profiles.push(profile);
-  });
-  if (profiles.length === 0) return defaults;
-  const defaultProfile = optionalString(value, "defaultProfile") ?? profiles[0].id;
-  if (!profiles.some((profile) => profile.id === defaultProfile)) diagnostics.push(sceneErrorDiagnostic("scene.device_unknown", `Default device profile not found: ${defaultProfile}.`, "devices.defaultProfile"));
-  return { defaultProfile, profiles };
-}
-function parseSetup(value, targetEnvironment, diagnostics) {
-  const record = isRecord(value) ? value : {};
-  const setup = {};
-  const dev = objectField(record, "dev", "setup", diagnostics);
-  if (dev) setup.dev = { required: booleanField(dev, "required", false, "setup.dev", diagnostics), command: optionalString(dev, "command"), reuseExisting: booleanField(dev, "reuseExisting", true, "setup.dev", diagnostics) };
-  const auth = objectField(record, "auth", "setup", diagnostics);
-  if (auth) setup.auth = {
-    profile: optionalString(auth, "profile"),
-    required: booleanField(auth, "required", false, "setup.auth", diagnostics),
-    seedOnly: booleanField(auth, "seedOnly", false, "setup.auth", diagnostics),
-    fixtureRoles: stringArrayField(auth, "fixtureRoles", "setup.auth", diagnostics),
-    ...optionalString(auth, "role") ? { role: optionalString(auth, "role") } : {}
-  };
-  const seeds = arrayField(record, "seeds", "setup", diagnostics) ?? [];
-  setup.seeds = seeds.filter(isRecord).map((seed, index) => {
-    const path = `setup.seeds[${index}]`;
-    const environments = (arrayField(seed, "environments", path, diagnostics) ?? [targetEnvironment]).map((entry, environmentIndex) => parseEnvironment(entry, `${path}.environments[${environmentIndex}]`, diagnostics, targetEnvironment));
-    return { name: requireString(seed, "name", path, diagnostics), environments: [...new Set(environments)], apply: booleanField(seed, "apply", false, path, diagnostics) };
-  });
-  return setup;
-}
-function parseArtifacts(value, diagnostics) {
-  const record = isRecord(value) ? value : {};
-  return {
-    trace: booleanField(record, "trace", true, "artifacts", diagnostics),
-    video: booleanField(record, "video", false, "artifacts", diagnostics),
-    screenshots: booleanField(record, "screenshots", true, "artifacts", diagnostics),
-    fullPageScreenshots: booleanField(record, "fullPageScreenshots", true, "artifacts", diagnostics),
-    console: booleanField(record, "console", true, "artifacts", diagnostics),
-    network: booleanField(record, "network", true, "artifacts", diagnostics),
-    timeline: booleanField(record, "timeline", true, "artifacts", diagnostics),
-    appLogs: booleanField(record, "appLogs", true, "artifacts", diagnostics)
-  };
-}
-export {
-  actionCanOmitExpectation,
-  defaultSceneDeviceConfig,
-  expectationKeys,
-  parseAction,
-  parseArtifacts,
-  parseDevices,
-  parseDimensionPair,
-  parseExpectation,
-  parseMode,
-  parseSetup,
-  parseTarget
-};

package/dist/scenes/schema/parse-agent-lab.d.ts

@@ -1,2 +0,0 @@
-import type { AgentLabSceneConfig, SceneDiagnostic } from '../types.js';
-export declare function parseAgentLab(value: unknown, diagnostics: SceneDiagnostic[]): AgentLabSceneConfig | undefined;

package/dist/scenes/schema/parse-agent-lab.js

@@ -1,87 +0,0 @@
-import { AGENT_LAB_PRESENTATIONS } from "../types/scene-agent-lab.js";
-import { sceneErrorDiagnostic } from "../support/reporting/diagnostics.js";
-import { FILESYSTEM_SAFE_SCENE_ID, asString, booleanField, isRecord, objectField, positiveNumberField, stringArrayField } from "./filesystem-safe-scene-id.js";
-function validTimeZone(value) {
-  try {
-    new Intl.DateTimeFormat("en-US", { timeZone: value }).format();
-    return true;
-  } catch {
-    return false;
-  }
-}
-function parseWorkday(value, index, diagnostics) {
-  const path = `agentLab.workdays[${index}]`;
-  if (!isRecord(value)) {
-    diagnostics.push(sceneErrorDiagnostic("scene.agent_lab_workday_invalid", "Agent Lab workdays must be objects.", path));
-    return null;
-  }
-  const id = asString(value.id);
-  if (!id || !FILESYSTEM_SAFE_SCENE_ID.test(id)) diagnostics.push(sceneErrorDiagnostic("scene.agent_lab_workday_id_invalid", "Agent Lab workday id must be file-safe.", `${path}.id`));
-  const agentTests = stringArrayField(value, "agentTests", path, diagnostics);
-  if (!agentTests.length) diagnostics.push(sceneErrorDiagnostic("scene.agent_lab_tests_required", "Agent Lab workdays require at least one agent test.", `${path}.agentTests`));
-  if (value.availableCredits !== void 0) diagnostics.push(sceneErrorDiagnostic("scene.agent_lab_legacy_credits_rejected", "availableCredits is a legacy accounting field. Configure timePolicy and planningSession instead.", `${path}.availableCredits`));
-  const timePolicy = objectField(value, "timePolicy", path, diagnostics) ?? {};
-  const planningSession = objectField(value, "planningSession", path, diagnostics) ?? {};
-  const cooperativePlanningPercent = positiveNumberField(timePolicy, "cooperativePlanningPercent", 90, `${path}.timePolicy`, diagnostics) ?? 90;
-  const governedExecutionPercent = typeof timePolicy.governedExecutionPercent === "number" ? timePolicy.governedExecutionPercent : 0;
-  const reservePercent = positiveNumberField(timePolicy, "reservePercent", 10, `${path}.timePolicy`, diagnostics) ?? 10;
-  if ([cooperativePlanningPercent, governedExecutionPercent, reservePercent].some((entry) => !Number.isFinite(entry) || entry < 0) || Math.abs(cooperativePlanningPercent + governedExecutionPercent + reservePercent - 100) > 1e-6) diagnostics.push(sceneErrorDiagnostic("scene.agent_lab_time_policy_invalid", "Workday Plan, Execute, and Reserve percentages must be nonnegative and total exactly 100.", `${path}.timePolicy`));
-  return {
-    id,
-    ...asString(value.title) ? { title: asString(value.title) } : {},
-    agentTests,
-    objectiveRefs: stringArrayField(value, "objectiveRefs", path, diagnostics),
-    durationSeconds: positiveNumberField(value, "durationSeconds", 1800, path, diagnostics) ?? 1800,
-    maxActiveAssignments: positiveNumberField(value, "maxActiveAssignments", 4, path, diagnostics) ?? 4,
-    planningOnly: booleanField(value, "planningOnly", true, path, diagnostics),
-    activityTypes: stringArrayField(value, "activityTypes", path, diagnostics),
-    timePolicy: { cooperativePlanningPercent, governedExecutionPercent, reservePercent },
-    planningSession: {
-      rounds: positiveNumberField(planningSession, "rounds", 3, `${path}.planningSession`, diagnostics) ?? 3,
-      assignmentTimeboxSeconds: positiveNumberField(planningSession, "assignmentTimeboxSeconds", 900, `${path}.planningSession`, diagnostics) ?? 900,
-      ...typeof planningSession.tokenWarning === "number" ? { tokenWarning: planningSession.tokenWarning } : {},
-      ...typeof planningSession.tokenHardLimit === "number" ? { tokenHardLimit: planningSession.tokenHardLimit } : {}
-    },
-    profileInputs: objectField(value, "profileInputs", path, diagnostics) ?? {}
-  };
-}
-function parseAgentLab(value, diagnostics) {
-  if (value === void 0) return void 0;
-  if (!isRecord(value)) {
-    diagnostics.push(sceneErrorDiagnostic("scene.agent_lab_invalid", "agentLab must be an object.", "agentLab"));
-    return void 0;
-  }
-  const scopeValue = objectField(value, "scope", "agentLab", diagnostics) ?? { kind: "ephemeral" };
-  const scopeKind = asString(scopeValue.kind) || "ephemeral";
-  if (!["team", "ephemeral"].includes(scopeKind)) diagnostics.push(sceneErrorDiagnostic("scene.agent_lab_scope_invalid", "Agent Lab scope kind must be team or ephemeral.", "agentLab.scope.kind"));
-  const scope = scopeKind === "team" ? { kind: "team", team: asString(scopeValue.team), capacityProvider: asString(scopeValue.capacityProvider) } : { kind: "ephemeral" };
-  if (scope.kind === "team" && (!scope.team || !scope.capacityProvider)) diagnostics.push(sceneErrorDiagnostic("scene.agent_lab_scope_reference_required", "Team scope requires team and capacityProvider seed resource keys.", "agentLab.scope"));
-  const provider = asString(value.provider) || "local";
-  if (provider !== "local") diagnostics.push(sceneErrorDiagnostic("scene.agent_lab_provider_invalid", "Agent Lab currently requires the local capacity provider.", "agentLab.provider"));
-  const executionProvider = asString(value.executionProvider) || "codex-treeseed";
-  if (!FILESYSTEM_SAFE_SCENE_ID.test(executionProvider)) diagnostics.push(sceneErrorDiagnostic("scene.agent_lab_execution_provider_invalid", "Agent Lab execution provider must be a file-safe configured provider id.", "agentLab.executionProvider"));
-  const presentation = asString(value.presentation) || "race-control";
-  if (!AGENT_LAB_PRESENTATIONS.includes(presentation)) diagnostics.push(sceneErrorDiagnostic("scene.agent_lab_presentation_invalid", `Unknown Agent Lab presentation: ${presentation}.`, "agentLab.presentation"));
-  const timeZone = asString(value.timeZone) || Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
-  if (!validTimeZone(timeZone)) diagnostics.push(sceneErrorDiagnostic("scene.agent_lab_timezone_invalid", `Invalid IANA time zone: ${timeZone}.`, "agentLab.timeZone"));
-  const repositories = stringArrayField(value, "repositories", "agentLab", diagnostics);
-  if (!repositories.length) diagnostics.push(sceneErrorDiagnostic("scene.agent_lab_repositories_required", "Agent Lab requires at least one repository.", "agentLab.repositories"));
-  const workdayValues = Array.isArray(value.workdays) ? value.workdays : [];
-  if (!workdayValues.length) diagnostics.push(sceneErrorDiagnostic("scene.agent_lab_workdays_required", "Agent Lab requires at least one workday.", "agentLab.workdays"));
-  const workdays = workdayValues.map((entry, index) => parseWorkday(entry, index, diagnostics)).filter((entry) => Boolean(entry));
-  if (new Set(workdays.map((entry) => entry.id)).size !== workdays.length) diagnostics.push(sceneErrorDiagnostic("scene.agent_lab_workday_duplicate", "Agent Lab workday ids must be unique.", "agentLab.workdays"));
-  return {
-    scope: scope.kind === "team" ? { kind: "team", team: scope.team ?? "", capacityProvider: scope.capacityProvider ?? "" } : scope,
-    provider: "local",
-    executionProvider,
-    presentation: AGENT_LAB_PRESENTATIONS.includes(presentation) ? presentation : "race-control",
-    timeZone,
-    repositories,
-    agents: stringArrayField(value, "agents", "agentLab", diagnostics),
-    agentClasses: stringArrayField(value, "agentClasses", "agentLab", diagnostics),
-    workdays
-  };
-}
-export {
-  parseAgentLab
-};

package/dist/scenes/schema/parse-diagrams.d.ts

@@ -1,7 +0,0 @@
-import { type SceneDiagnostic, type SceneDiagram, type SceneMode, type SceneRenderConfig, type SceneRuntimeConfig, type SceneTrainingConfig, type SceneVisualAuditConfig } from '../types.js';
-export declare function parseDiagrams(value: unknown, stepIds: Set<string>, diagnostics: SceneDiagnostic[]): SceneDiagram[];
-export declare function parseRender(value: unknown, diagnostics: SceneDiagnostic[]): SceneRenderConfig;
-export declare function parseRuntime(value: unknown, mode: SceneMode, diagnostics: SceneDiagnostic[]): SceneRuntimeConfig;
-export declare function defaultSceneTrainingConfig(): SceneTrainingConfig;
-export declare function parseTraining(value: unknown, stepIds: Set<string>, diagnostics: SceneDiagnostic[]): SceneTrainingConfig;
-export declare function defaultSceneVisualAuditConfig(): SceneVisualAuditConfig;

package/dist/scenes/schema/parse-diagrams.js

@@ -1,225 +0,0 @@
-import { sceneErrorDiagnostic, sceneWarningDiagnostic } from "../support/reporting/diagnostics.js";
-import { CAPTION_FORMATS, DIAGRAM_PLACEMENTS, EVIDENCE_FITS, FILESYSTEM_SAFE_SCENE_ID, NARRATION_STYLES, TRANSCRIPT_FORMATS, arrayField, asString, booleanField, enumArrayField, isRecord, nullablePositiveNumberField, objectField, optionalString, positiveNumberField, requireString, stringArrayField } from "./filesystem-safe-scene-id.js";
-import { parseMotion, parseVisualObjects, parseVisualStyle } from "./parse-workflow.js";
-function parseDiagrams(value, stepIds, diagnostics) {
-  const diagrams = [];
-  const entries = Array.isArray(value) ? value : [];
-  entries.forEach((entry, index) => {
-    const path = `diagrams[${index}]`;
-    if (!isRecord(entry)) {
-      diagnostics.push(sceneErrorDiagnostic("scene.invalid_diagram", "Expected diagram to be an object.", path));
-      return;
-    }
-    const id = requireString(entry, "id", path, diagnostics);
-    const at = requireString(entry, "at", path, diagnostics);
-    if (id && !FILESYSTEM_SAFE_SCENE_ID.test(id)) diagnostics.push(sceneErrorDiagnostic("scene.invalid_id", `Invalid diagram id: ${id}.`, `${path}.id`));
-    if (at && !stepIds.has(at)) diagnostics.push(sceneErrorDiagnostic("scene.unknown_step_reference", `Unknown workflow step reference: ${at}.`, `${path}.at`));
-    const placementValue = optionalString(entry, "placement") ?? "interstitial";
-    const placement = DIAGRAM_PLACEMENTS.includes(placementValue) ? placementValue : "interstitial";
-    if (placementValue && placementValue !== placement) diagnostics.push(sceneErrorDiagnostic("scene.diagram_invalid_placement", `Unknown diagram placement: ${placementValue}.`, `${path}.placement`));
-    const objects = parseVisualObjects(entry.objects, `${path}.objects`, diagnostics);
-    const motion = parseMotion(entry.motion, `${path}.motion`, diagnostics);
-    const style = parseVisualStyle(entry.style, `${path}.style`, diagnostics);
-    diagrams.push({
-      id,
-      at,
-      renderer: requireString(entry, "renderer", path, diagnostics),
-      component: requireString(entry, "component", path, diagnostics),
-      durationSeconds: positiveNumberField(entry, "durationSeconds", void 0, path, diagnostics),
-      placement,
-      props: objectField(entry, "props", path, diagnostics),
-      ...objects ? { objects } : {},
-      ...motion ? { motion } : {},
-      ...style ? { style } : {}
-    });
-  });
-  return diagrams;
-}
-function parseRender(value, diagnostics) {
-  const record = isRecord(value) ? value : {};
-  const remotion = objectField(record, "remotion", "render", diagnostics);
-  if (!remotion) return {};
-  const output = objectField(remotion, "output", "render.remotion", diagnostics);
-  const resolution = output ? objectField(output, "resolution", "render.remotion.output", diagnostics) : void 0;
-  const capture = objectField(remotion, "capture", "render.remotion", diagnostics);
-  const captureViewport = capture ? objectField(capture, "viewport", "render.remotion.capture", diagnostics) : void 0;
-  const captureVideo = capture ? objectField(capture, "video", "render.remotion.capture", diagnostics) : void 0;
-  const evidenceFitValue = capture ? optionalString(capture, "evidenceFit") ?? "fixed-browser" : "fixed-browser";
-  const evidenceFit = EVIDENCE_FITS.includes(evidenceFitValue) ? evidenceFitValue : "fixed-browser";
-  if (capture && evidenceFitValue !== evidenceFit) diagnostics.push(sceneErrorDiagnostic("scene.render_capture_fit_invalid", `Unknown scene render evidence fit: ${evidenceFitValue}.`, "render.remotion.capture.evidenceFit"));
-  const browserFrame = objectField(remotion, "browserFrame", "render.remotion", diagnostics);
-  return {
-    remotion: {
-      composition: optionalString(remotion, "composition"),
-      ...output ? {
-        output: {
-          format: optionalString(output, "format"),
-          fps: positiveNumberField(output, "fps", void 0, "render.remotion.output", diagnostics),
-          ...resolution ? { resolution: { width: positiveNumberField(resolution, "width", 1920, "render.remotion.output.resolution", diagnostics) ?? 1920, height: positiveNumberField(resolution, "height", 1080, "render.remotion.output.resolution", diagnostics) ?? 1080 } } : {}
-        }
-      } : {},
-      ...capture ? {
-        capture: {
-          ...captureViewport ? { viewport: { width: positiveNumberField(captureViewport, "width", 1600, "render.remotion.capture.viewport", diagnostics) ?? 1600, height: positiveNumberField(captureViewport, "height", 900, "render.remotion.capture.viewport", diagnostics) ?? 900 } } : {},
-          ...captureVideo ? { video: { width: positiveNumberField(captureVideo, "width", 1600, "render.remotion.capture.video", diagnostics) ?? 1600, height: positiveNumberField(captureVideo, "height", 900, "render.remotion.capture.video", diagnostics) ?? 900 } } : {},
-          evidenceFit
-        }
-      } : {},
-      ...browserFrame ? {
-        browserFrame: {
-          enabled: booleanField(browserFrame, "enabled", false, "render.remotion.browserFrame", diagnostics),
-          ...optionalString(browserFrame, "title") ? { title: optionalString(browserFrame, "title") } : {}
-        }
-      } : {}
-    }
-  };
-}
-function parseRuntime(value, mode, diagnostics) {
-  const record = isRecord(value) ? value : {};
-  const modeValue = asString(record.mode);
-  let runtimeMode = modeValue || (mode.test ? "acceptance" : mode.training ? "training" : mode.demo ? "demo" : "acceptance");
-  if (!["acceptance", "demo", "training", "record-only"].includes(runtimeMode)) {
-    diagnostics.push(sceneErrorDiagnostic("scene.invalid_runtime_mode", `Unknown runtime mode: ${runtimeMode}.`, "runtime.mode"));
-    runtimeMode = "acceptance";
-  }
-  const timeouts = objectField(record, "timeouts", "runtime", diagnostics) ?? {};
-  const checkpoints = objectField(record, "checkpoints", "runtime", diagnostics) ?? {};
-  const progress = objectField(record, "progress", "runtime", diagnostics) ?? {};
-  const failure = objectField(record, "failure", "runtime", diagnostics) ?? {};
-  return {
-    mode: runtimeMode,
-    timeouts: {
-      sceneSeconds: nullablePositiveNumberField(timeouts, "sceneSeconds", null, "runtime.timeouts", diagnostics),
-      chapterSeconds: nullablePositiveNumberField(timeouts, "chapterSeconds", null, "runtime.timeouts", diagnostics),
-      stepSeconds: positiveNumberField(timeouts, "stepSeconds", 120, "runtime.timeouts", diagnostics) ?? 120
-    },
-    checkpoints: {
-      enabled: booleanField(checkpoints, "enabled", true, "runtime.checkpoints", diagnostics),
-      defaultResumable: booleanField(checkpoints, "defaultResumable", false, "runtime.checkpoints", diagnostics),
-      everyStep: booleanField(checkpoints, "everyStep", true, "runtime.checkpoints", diagnostics)
-    },
-    progress: {
-      heartbeatSeconds: positiveNumberField(progress, "heartbeatSeconds", 15, "runtime.progress", diagnostics) ?? 15
-    },
-    failure: {
-      continueOnFailure: booleanField(failure, "continueOnFailure", false, "runtime.failure", diagnostics)
-    }
-  };
-}
-function defaultSceneTrainingConfig() {
-  return {
-    enabled: true,
-    captions: {
-      enabled: true,
-      formats: ["vtt", "srt"],
-      maxCueSeconds: 6,
-      renderInTrainingVideo: true
-    },
-    transcript: {
-      enabled: true,
-      formats: ["json", "markdown"]
-    },
-    narration: {
-      enabled: true,
-      style: "instructional",
-      includeDiagnostics: true
-    },
-    glossary: {
-      enabled: true,
-      terms: []
-    },
-    chapterClips: {
-      enabled: true,
-      format: "manifest"
-    }
-  };
-}
-function parseTraining(value, stepIds, diagnostics) {
-  const record = isRecord(value) ? value : {};
-  for (const key of Object.keys(record)) {
-    if (!["enabled", "captions", "transcript", "narration", "glossary", "chapterClips"].includes(key)) diagnostics.push(sceneWarningDiagnostic("scene.unknown_training_field", `Unknown training field: ${key}.`, `training.${key}`));
-  }
-  const captions = objectField(record, "captions", "training", diagnostics) ?? {};
-  const transcript = objectField(record, "transcript", "training", diagnostics) ?? {};
-  const narration = objectField(record, "narration", "training", diagnostics) ?? {};
-  const glossary = objectField(record, "glossary", "training", diagnostics) ?? {};
-  const chapterClips = objectField(record, "chapterClips", "training", diagnostics) ?? {};
-  const styleValue = asString(narration.style) || "instructional";
-  const style = NARRATION_STYLES.includes(styleValue) ? styleValue : "instructional";
-  if (styleValue !== style) diagnostics.push(sceneErrorDiagnostic("scene.training_invalid_config", `Unknown narration style: ${styleValue}.`, "training.narration.style"));
-  const terms = (arrayField(glossary, "terms", "training.glossary", diagnostics) ?? []).map((entry, index) => {
-    const path = `training.glossary.terms[${index}]`;
-    if (!isRecord(entry)) {
-      diagnostics.push(sceneErrorDiagnostic("scene.training_invalid_config", "Glossary term entries must be objects.", path));
-      return null;
-    }
-    const term = requireString(entry, "term", path, diagnostics);
-    const sourceStep = optionalString(entry, "sourceStep");
-    if (sourceStep && !stepIds.has(sourceStep)) diagnostics.push(sceneErrorDiagnostic("scene.unknown_step_reference", `Unknown workflow step reference: ${sourceStep}.`, `${path}.sourceStep`));
-    const tags = stringArrayField(entry, "tags", path, diagnostics);
-    return {
-      term,
-      ...optionalString(entry, "definition") ? { definition: optionalString(entry, "definition") } : {},
-      ...sourceStep ? { sourceStep } : {},
-      ...tags.length > 0 ? { tags } : {}
-    };
-  }).filter((entry) => Boolean(entry));
-  const clipFormat = asString(chapterClips.format) || "manifest";
-  if (clipFormat !== "manifest") diagnostics.push(sceneErrorDiagnostic("scene.training_invalid_config", `Unsupported chapter clip format: ${clipFormat}.`, "training.chapterClips.format"));
-  return {
-    enabled: booleanField(record, "enabled", true, "training", diagnostics),
-    captions: {
-      enabled: booleanField(captions, "enabled", true, "training.captions", diagnostics),
-      formats: enumArrayField(captions, "formats", CAPTION_FORMATS, ["vtt", "srt"], "training.captions", diagnostics),
-      maxCueSeconds: positiveNumberField(captions, "maxCueSeconds", 6, "training.captions", diagnostics) ?? 6,
-      renderInTrainingVideo: booleanField(captions, "renderInTrainingVideo", true, "training.captions", diagnostics)
-    },
-    transcript: {
-      enabled: booleanField(transcript, "enabled", true, "training.transcript", diagnostics),
-      formats: enumArrayField(transcript, "formats", TRANSCRIPT_FORMATS, ["json", "markdown"], "training.transcript", diagnostics)
-    },
-    narration: {
-      enabled: booleanField(narration, "enabled", true, "training.narration", diagnostics),
-      style,
-      includeDiagnostics: booleanField(narration, "includeDiagnostics", true, "training.narration", diagnostics)
-    },
-    glossary: {
-      enabled: booleanField(glossary, "enabled", true, "training.glossary", diagnostics),
-      terms
-    },
-    chapterClips: {
-      enabled: booleanField(chapterClips, "enabled", true, "training.chapterClips", diagnostics),
-      format: "manifest"
-    }
-  };
-}
-function defaultSceneVisualAuditConfig() {
-  return {
-    enabled: true,
-    roles: ["anonymous", "owner", "admin", "member"],
-    pathRoots: [],
-    pathGlobs: [],
-    excludePathGlobs: [],
-    includeFullPage: false,
-    review: {
-      enabled: true,
-      detail: "standard",
-      maxFindings: 250,
-      contactSheets: true
-    },
-    routeDiscovery: {
-      core: true,
-      admin: true,
-      tenantOverrides: true,
-      contentCollections: true
-    }
-  };
-}
-export {
-  defaultSceneTrainingConfig,
-  defaultSceneVisualAuditConfig,
-  parseDiagrams,
-  parseRender,
-  parseRuntime,
-  parseTraining
-};

package/dist/scenes/schema/parse-visual-audit.d.ts

@@ -1,6 +0,0 @@
-import { type SceneAction, type SceneDiagnostic, type SceneExpectation, type SceneManifest, type SceneVisualAuditConfig } from '../types.js';
-export declare function parseVisualAudit(value: unknown, diagnostics: SceneDiagnostic[]): SceneVisualAuditConfig;
-export declare function actionKind(action: SceneAction): string;
-export declare function sceneActionKind(action: SceneAction): string;
-export declare function sceneExpectationKinds(expectation: SceneExpectation | undefined): string[];
-export declare function parseSceneManifest(value: unknown, diagnostics: SceneDiagnostic[]): SceneManifest | null;