@hraness/slopcamera 3.2.7 → 3.3.1

package/apps/desktop/code/semantic-builder.ts

@@ -4,6 +4,12 @@ import type {
   CandidateProjectRenderInput,
   SpatialInspectInput, SpatialInspectOutput, SpatialPatchInput, SpatialPatchOutput,
   SpatialEvaluateInput, SpatialEvaluateOutput,
+  SpatialDirectionCheckInput, SpatialDirectionCheckOutput,
+  SpatialDirectionCompileInput, SpatialDirectionCompileOutput,
+  SpatialDirectionGalleryInput, SpatialDirectionGalleryOutput,
+  SpatialEffectsCheckInput, SpatialEffectsCheckOutput,
+  SpatialEffectsPlanInput, SpatialEffectsPlanOutput,
+  SpatialTemporalAuditInput, SpatialTemporalAuditOutput,
   BindCandidateRevisionOutput,
   CommitProjectEditsOutput,
   CreateCandidateRevisionOutput,
@@ -50,11 +56,6 @@ import type {
   ProjectRenderPlanOutput,
   ProjectSnapshotOutput,
   PromoteVariantSelectionOutput,
-  RecordingPauseOutput,
-  RecordingResumeOutput,
-  RecordingStartInput,
-  RecordingStartOutput,
-  RecordingStopOutput,
   SceneAnalysisOperationInput,
   SceneAnalysisOperationOutput,
   SelectVariantInput,
@@ -301,8 +302,6 @@ export type MediaAudioEffectsOptions =
   OperationInputValue<MediaAudioEffectsInput>;
 export type MediaColorGradeOptions =
   OperationInputValue<MediaColorGradeInput>;
-export type RecordingStartOptions =
-  OperationInputValue<RecordingStartInput>;
 
 export type FaceFollowOptions = {
   readonly [Key in keyof Omit<FollowFacesInput, "project">]:
@@ -1043,6 +1042,24 @@ export class WorkflowBuilder {
       this.#graph.operationByKind(key, { input, kind: "scene.patch", version: 1 }, options),
     evaluate: (key: string, input: OperationInputValue<SpatialEvaluateInput>, options?: OperationNodeOptions): Ref<SpatialEvaluateOutput> =>
       this.#graph.operationByKind(key, { input, kind: "scene.evaluate", version: 1 }, options),
+    /**
+     * Pure semantic planning and review operations: direction checking and
+     * compilation, bounded galleries, render-effects binding, and sampled
+     * temporal audit. They propose and review documents; they never mutate a
+     * project, render media, or select a candidate.
+     */
+    directionCheck: (key: string, input: OperationInputValue<SpatialDirectionCheckInput> | SpatialDirectionCheckInput, options?: OperationNodeOptions): Ref<SpatialDirectionCheckOutput> =>
+      this.#graph.operationByKind(key, { input, kind: "scene.direction.check", version: 1 }, options),
+    directionCompile: (key: string, input: OperationInputValue<SpatialDirectionCompileInput> | SpatialDirectionCompileInput, options?: OperationNodeOptions): Ref<SpatialDirectionCompileOutput> =>
+      this.#graph.operationByKind(key, { input, kind: "scene.direction.compile", version: 1 }, options),
+    directionGallery: (key: string, input: OperationInputValue<SpatialDirectionGalleryInput> | SpatialDirectionGalleryInput, options?: OperationNodeOptions): Ref<SpatialDirectionGalleryOutput> =>
+      this.#graph.operationByKind(key, { input, kind: "scene.direction.gallery", version: 1 }, options),
+    effectsCheck: (key: string, input: OperationInputValue<SpatialEffectsCheckInput> | SpatialEffectsCheckInput, options?: OperationNodeOptions): Ref<SpatialEffectsCheckOutput> =>
+      this.#graph.operationByKind(key, { input, kind: "scene.effects.check", version: 1 }, options),
+    effectsPlan: (key: string, input: OperationInputValue<SpatialEffectsPlanInput> | SpatialEffectsPlanInput, options?: OperationNodeOptions): Ref<SpatialEffectsPlanOutput> =>
+      this.#graph.operationByKind(key, { input, kind: "scene.effects.plan", version: 1 }, options),
+    temporalAudit: (key: string, input: OperationInputValue<SpatialTemporalAuditInput> | SpatialTemporalAuditInput, options?: OperationNodeOptions): Ref<SpatialTemporalAuditOutput> =>
+      this.#graph.operationByKind(key, { input, kind: "scene.temporal-audit", version: 1 }, options),
   });
 
   readonly spatialProject = Object.freeze({
@@ -1344,42 +1361,6 @@ export class WorkflowBuilder {
     }, options),
   });
 
-  readonly recording = Object.freeze({
-    pause: (
-      key: string,
-      options?: OperationNodeOptions,
-    ): Ref<RecordingPauseOutput> => this.#graph.operationByKind(key, {
-      input: {},
-      kind: "recording.pause",
-      version: 1,
-    }, options),
-    resume: (
-      key: string,
-      options?: OperationNodeOptions,
-    ): Ref<RecordingResumeOutput> => this.#graph.operationByKind(key, {
-      input: {},
-      kind: "recording.resume",
-      version: 1,
-    }, options),
-    start: (
-      key: string,
-      input: RecordingStartOptions,
-      options?: OperationNodeOptions,
-    ): Ref<RecordingStartOutput> => this.#graph.operationByKind(key, {
-      input,
-      kind: "recording.start",
-      version: 2,
-    }, options),
-    stop: (
-      key: string,
-      options?: OperationNodeOptions,
-    ): Ref<RecordingStopOutput> => this.#graph.operationByKind(key, {
-      input: {},
-      kind: "recording.stop",
-      version: 1,
-    }, options),
-  });
-
   private constructor(graph: WorkflowGraphBuilder) {
     this.#graph = graph;
   }

package/apps/desktop/code/source-bundle.ts

@@ -28,6 +28,7 @@ import {
   canonicalJson,
   sha256Hex,
 } from "../core/canonical-json";
+import { hostSourceRoots } from "./host-source-layout";
 import type { WorkflowBundleIdentity as GraphWorkflowBundleIdentity } from "./contracts";
 import { typecheckWorkflowSnapshot } from "./source-typecheck";
 import { captureWorkerProcessStartIdentity } from "./worker-process-identity";
@@ -52,6 +53,10 @@ const MAX_TIMER_DURATION_MS = 2_147_483_647;
 const BUNDLER_GUARDIAN_HANDSHAKE_MS = 2_000;
 const BUNDLER_GUARDIAN_DIAGNOSTIC_BYTES = 2_000;
 
+// Spawned helpers always run the checked TypeScript sources, never a path
+// derived from this module's bundled location below apps/desktop/dist/cli.
+const HOST_ROOTS = hostSourceRoots(import.meta.dir);
+
 const BUNDLE_SUBPROCESS_SOURCE = String.raw`
 import { fstatSync } from "node:fs";
 const processIdentity = await import(process.argv[5]);
@@ -756,11 +761,16 @@ async function startBundlerRetirementGuardian(options: {
         "--has-lease",
         options.inheritedHostResourceFileDescriptor === 0 ? "false" : "true",
         "--identity-module",
-        pathToFileURL(join(import.meta.dir, "worker-process-identity.ts")).href,
+        pathToFileURL(join(
+          HOST_ROOTS.desktopRoot,
+          "code",
+          "worker-process-identity.ts",
+        )).href,
         "--host-resource-lock-module",
         pathToFileURL(join(
-          import.meta.dir,
-          "../../../src/host-resource-posix.ts",
+          HOST_ROOTS.repositoryRoot,
+          "src",
+          "host-resource-posix.ts",
         )).href,
       ],
       {
@@ -941,6 +951,7 @@ async function buildWorkflowBundle(
   modules: readonly CapturedSourceModule[],
   aliases: Readonly<Record<string, string>>,
   configSearchPath: string,
+  hostBoundary: string,
   includeRuntimeTypes: boolean,
   semanticCheck: boolean,
   inheritedHostResourceFileDescriptor: number,
@@ -979,6 +990,7 @@ async function buildWorkflowBundle(
         aliases,
         configSearchPath,
         entryPath,
+        hostBoundary,
         includeRuntimeTypes,
         sourceRoot,
       });
@@ -997,7 +1009,11 @@ async function buildWorkflowBundle(
         outputPath,
         inheritedHostResourceFileDescriptor === 0 ? "0" : "3",
         String(maximumBundleBytes),
-        pathToFileURL(join(import.meta.dir, "worker-process-identity.ts")).href,
+        pathToFileURL(join(
+          HOST_ROOTS.desktopRoot,
+          "code",
+          "worker-process-identity.ts",
+        )).href,
       ],
       {
         cwd: sourceRoot,
@@ -1571,14 +1587,15 @@ async function bundleWorkflowSourceInternal(
   const aliasSpecifiers = new Set(sourceGraph.bareImports);
   const aliases = await bareImportAliases(
     [...aliasSpecifiers].sort(),
-    resolve(options.bareImportResolutionRoot ?? import.meta.dir),
+    resolve(options.bareImportResolutionRoot ?? HOST_ROOTS.desktopRoot),
   );
   const entryRelativePath = relative(allowedRoot, entryPath);
   const bytes = await buildWorkflowBundle(
     entryRelativePath,
     sourceGraph.modules,
     aliases,
-    resolve(options.bareImportResolutionRoot ?? import.meta.dir),
+    resolve(options.bareImportResolutionRoot ?? HOST_ROOTS.desktopRoot),
+    HOST_ROOTS.repositoryRoot,
     (
       sourceGraph.bareImports.some(specifier => (
         specifier === "bun" || specifier.startsWith("node:")

package/apps/desktop/code/source-typecheck.ts

@@ -1,4 +1,4 @@
-import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 
 import ts from "typescript";
 
@@ -12,11 +12,38 @@ const WORKFLOW_GLOBALS_SOURCE = [
   "declare const process: any;",
   "",
 ].join("\n");
+// Packed distributions ship no host tsconfig; this closed fallback preserves
+// the host compiler contract instead of adopting a foreign caller tsconfig.
+const PACKED_WORKFLOW_CONFIG = {
+  compilerOptions: {
+    allowImportingTsExtensions: true,
+    exactOptionalPropertyTypes: true,
+    isolatedModules: true,
+    jsx: "react-jsx",
+    lib: ["ES2023", "DOM", "DOM.Iterable"],
+    module: "Preserve",
+    moduleDetection: "force",
+    moduleResolution: "Bundler",
+    noEmit: true,
+    noFallthroughCasesInSwitch: true,
+    noImplicitOverride: true,
+    noImplicitReturns: true,
+    noUncheckedIndexedAccess: true,
+    noUnusedLocals: true,
+    noUnusedParameters: true,
+    skipLibCheck: true,
+    strict: true,
+    target: "ES2023",
+    useUnknownInCatchVariables: true,
+    verbatimModuleSyntax: true,
+  },
+};
 
 export interface TypecheckWorkflowSnapshotOptions {
   readonly aliases: Readonly<Record<string, string>>;
   readonly configSearchPath: string;
   readonly entryPath: string;
+  readonly hostBoundary: string;
   readonly includeRuntimeTypes: boolean;
   readonly sourceRoot: string;
 }
@@ -26,6 +53,37 @@ function isWithin(root: string, candidate: string): boolean {
   return fromRoot === "" || (!fromRoot.startsWith("..") && !isAbsolute(fromRoot));
 }
 
+/** Finds the host tsconfig without crossing into a foreign caller tree. */
+function boundedHostConfigPath(
+  searchPath: string,
+  boundary: string,
+): string | undefined {
+  const limit = resolve(boundary);
+  let candidate = resolve(searchPath);
+  while (isWithin(limit, candidate)) {
+    const path = join(candidate, "tsconfig.json");
+    if (ts.sys.fileExists(path)) return path;
+    const parent = dirname(candidate);
+    if (parent === candidate) return undefined;
+    candidate = parent;
+  }
+  return undefined;
+}
+
+/**
+ * Resolves the installed @types/bun package from the host tree so runtime
+ * types never depend on the caller's working directory or dependencies.
+ */
+function bunTypeRoots(hostBoundary: string): string | undefined {
+  try {
+    return dirname(dirname(
+      Bun.resolveSync("@types/bun/package.json", resolve(hostBoundary)),
+    ));
+  } catch {
+    return undefined;
+  }
+}
+
 function diagnosticText(
   diagnostic: ts.Diagnostic,
   sourceRoot: string,
@@ -77,49 +135,72 @@ function boundedDiagnostics(
 export function typecheckWorkflowSnapshot(
   options: TypecheckWorkflowSnapshotOptions,
 ): void {
-  const configPath = ts.findConfigFile(
-    resolve(options.configSearchPath),
-    path => ts.sys.fileExists(path),
-    "tsconfig.json",
+  const configPath = boundedHostConfigPath(
+    options.configSearchPath,
+    options.hostBoundary,
   );
+  const hostDirectory = configPath === undefined
+    ? resolve(options.hostBoundary)
+    : dirname(configPath);
+  let parsedOptions: ts.CompilerOptions;
   if (configPath === undefined) {
-    throw new ApplicationError(
-      "internal",
-      "Workflow semantic checking could not locate the host TypeScript configuration.",
+    const parsed = ts.parseJsonConfigFileContent(
+      PACKED_WORKFLOW_CONFIG,
+      ts.sys,
+      hostDirectory,
+      {
+        composite: false,
+        declaration: false,
+        emitDeclarationOnly: false,
+        incremental: false,
+        noEmit: true,
+      },
+      "slopcamera-packed-workflow.tsconfig.json",
     );
-  }
-  const config = ts.readConfigFile(configPath, path => ts.sys.readFile(path));
-  if (config.error !== undefined) {
-    throw new ApplicationError(
-      "internal",
-      `Workflow semantic checking could not read the host TypeScript configuration: ${
-        diagnosticText(config.error, options.sourceRoot)
-      }`,
-    );
-  }
-  const parsed = ts.parseJsonConfigFileContent(
-    config.config,
-    ts.sys,
-    dirname(configPath),
-    {
-      composite: false,
-      declaration: false,
-      emitDeclarationOnly: false,
-      incremental: false,
-      noEmit: true,
-    },
-    configPath,
-  );
-  if (parsed.errors.length > 0) {
-    throw new ApplicationError(
-      "internal",
-      `Workflow semantic checking could not parse the host TypeScript configuration:\n${
-        boundedDiagnostics(parsed.errors, options.sourceRoot)
-      }`,
+    if (parsed.errors.length > 0) {
+      throw new ApplicationError(
+        "internal",
+        `Workflow semantic checking could not apply its packed TypeScript configuration:\n${
+          boundedDiagnostics(parsed.errors, options.sourceRoot)
+        }`,
+      );
+    }
+    parsedOptions = parsed.options;
+  } else {
+    const config = ts.readConfigFile(configPath, path => ts.sys.readFile(path));
+    if (config.error !== undefined) {
+      throw new ApplicationError(
+        "internal",
+        `Workflow semantic checking could not read the host TypeScript configuration: ${
+          diagnosticText(config.error, options.sourceRoot)
+        }`,
+      );
+    }
+    const parsed = ts.parseJsonConfigFileContent(
+      config.config,
+      ts.sys,
+      hostDirectory,
+      {
+        composite: false,
+        declaration: false,
+        emitDeclarationOnly: false,
+        incremental: false,
+        noEmit: true,
+      },
+      configPath,
     );
+    if (parsed.errors.length > 0) {
+      throw new ApplicationError(
+        "internal",
+        `Workflow semantic checking could not parse the host TypeScript configuration:\n${
+          boundedDiagnostics(parsed.errors, options.sourceRoot)
+        }`,
+      );
+    }
+    parsedOptions = parsed.options;
   }
   const typecheckImporterPath = resolve(
-    dirname(configPath),
+    hostDirectory,
     "slopcamera-workflow-typecheck.ts",
   );
   const aliasPaths = Object.fromEntries(
@@ -132,7 +213,7 @@ export function typecheckWorkflowSnapshot(
         const declaration = ts.resolveModuleName(
           specifier,
           typecheckImporterPath,
-          parsed.options,
+          parsedOptions,
           ts.sys,
         ).resolvedModule?.resolvedFileName;
         return [
@@ -143,8 +224,14 @@ export function typecheckWorkflowSnapshot(
         ];
       }),
   );
+  // Runtime-typed workflows use the host's installed @types/bun when it is
+  // present and the explicit any-globals shim when it is not.
+  const runtimeTypeRoots = options.includeRuntimeTypes
+    ? bunTypeRoots(options.hostBoundary)
+    : undefined;
+  const realRuntimeTypes = runtimeTypeRoots !== undefined;
   const compilerOptions: ts.CompilerOptions = {
-    ...parsed.options,
+    ...parsedOptions,
     baseUrl: options.sourceRoot,
     composite: false,
     declaration: false,
@@ -152,10 +239,11 @@ export function typecheckWorkflowSnapshot(
     incremental: false,
     noEmit: true,
     paths: {
-      ...parsed.options.paths,
+      ...parsedOptions.paths,
       ...aliasPaths,
     },
-    types: options.includeRuntimeTypes ? ["bun"] : [],
+    ...(realRuntimeTypes ? { typeRoots: [runtimeTypeRoots] } : {}),
+    types: realRuntimeTypes ? ["bun"] : [],
   };
   delete compilerOptions.tsBuildInfoFile;
   const host = ts.createCompilerHost(compilerOptions, true);
@@ -189,7 +277,7 @@ export function typecheckWorkflowSnapshot(
     options: compilerOptions,
     rootNames: [
       options.entryPath,
-      ...(options.includeRuntimeTypes ? [] : [WORKFLOW_GLOBALS_PATH]),
+      ...(realRuntimeTypes ? [] : [WORKFLOW_GLOBALS_PATH]),
     ],
   });
   const diagnostics = program.getSourceFiles()

package/apps/desktop/code/worker-client.ts

@@ -22,6 +22,7 @@ import { z } from "zod";
 
 import { ApplicationError } from "../application/errors";
 import type { OperationDiscovery } from "../application/registry";
+import { hostSourceRoots } from "./host-source-layout";
 import { canonicalJson } from "../core/canonical-json";
 import {
   AuthoredWorkflowGraphV1Schema,
@@ -46,6 +47,9 @@ const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_MAXIMUM_DIAGNOSTIC_BYTES = 64 * 1024;
 const CODE_WORKER_CANCEL_GRACE_MS = 250;
 export const MAX_CODE_WORKER_POOL_SIZE = 4;
+// Spawned helpers always run the checked TypeScript sources, never a path
+// derived from this module's bundled location below apps/desktop/dist/cli.
+const HOST_ROOTS = hostSourceRoots(import.meta.dir);
 
 const WorkerBuiltWorkflowSchema = z.strictObject({
   graph: AuthoredWorkflowGraphV1Schema,
@@ -856,7 +860,11 @@ async function startCodeWorkerLeaseGuardian(options: {
       "Code-worker host-resource lease descriptor is unsafe to inherit.",
     );
   }
-  const guardianEntryPath = join(import.meta.dir, "worker-lease-guardian.ts");
+  const guardianEntryPath = join(
+    HOST_ROOTS.desktopRoot,
+    "code",
+    "worker-lease-guardian.ts",
+  );
   const guardian = spawn(
     options.bunExecutable,
     [
@@ -1435,7 +1443,11 @@ export async function startCodeWorker(
     );
   }
   const workerEntryPath = resolve(
-    options.workerEntryPath ?? join(import.meta.dir, "worker-entry.ts"),
+    options.workerEntryPath ?? join(
+      HOST_ROOTS.desktopRoot,
+      "code",
+      "worker-entry.ts",
+    ),
   );
   const workerEntrySha256 = createHash("sha256")
     .update(await readFile(workerEntryPath))