@hraness/slopcamera 3.10.0 → 3.10.1

package/PRIVACY.md

@@ -53,3 +53,11 @@ from vulnerability reports.
 
 Report suspected vulnerabilities through GitHub private vulnerability
 reporting at https://github.com/hraness/slopcamera/security/advisories/new.
+
+The public slopcamera.com website sends cookieless page views, page exits,
+performance measurements, explicit link and install-copy actions, missing-page
+reports, and rate-limited redacted client errors to PostHog. It keeps no person
+profiles, analytics cookies, or session recordings and respects Do Not Track.
+Public campaign parameters are retained; other query values and credentials
+are removed. Sensitive paths collapse to `/private` and their campaign
+attribution is removed. Preview builds and the inert preview page send nothing.

package/apps/desktop/application/operation.ts

@@ -4,7 +4,7 @@ import type { z } from "zod";
 
 import type { ApplicationContext } from "./context";
 
-export const SLOPCAMERA_APPLICATION_TOOL_VERSION = "slopcamera-3.10.0" as const;
+export const SLOPCAMERA_APPLICATION_TOOL_VERSION = "slopcamera-3.10.1" as const;
 
 export const OPERATION_KINDS = [
   "scene.audit",

package/apps/desktop/cli/commands.ts

@@ -365,7 +365,7 @@ import {
   workflowRunStore,
 } from "./workflow-runs";
 
-export const SLOPCAMERA_VERSION = "3.10.0";
+export const SLOPCAMERA_VERSION = "3.10.1";
 
 // Legacy direct renders predate per-target output contracts. Keep them
 // bounded generously enough for long-form production while preventing one

package/apps/desktop/cli/html-overlay-renderer.ts

@@ -23,6 +23,8 @@ import { basename, dirname, join } from "node:path";
 
 import { z } from "zod";
 
+import { verifyStableBrowserWatcherBaseline } from "./html-overlay-watcher-baseline";
+
 import {
   chromium,
   type Browser,
@@ -2020,6 +2022,8 @@ export class PlaywrightHtmlOverlayRenderer implements HtmlOverlayRenderer {
         signal,
       );
       browserRuntimeSnapshot = preparedBrowserRuntime;
+      let watcherVersion = 0;
+      let watcherFailure: Error | undefined;
       const runtimeName = basename(preparedBrowserRuntime.runtimeRoot);
       const snapshotName = basename(preparedBrowserRuntime.directory);
       const anchorWatcher = watch(
@@ -2028,11 +2032,13 @@ export class PlaywrightHtmlOverlayRenderer implements HtmlOverlayRenderer {
         (eventType, filename) => {
           const path = filename?.toString() ?? "<snapshot-anchor>";
           if (path === snapshotName) {
+            watcherVersion += 1;
             browserRuntimeMutations.add(`anchor-${eventType}:${path}`);
           }
         },
       );
       anchorWatcher.on("error", error => {
+        watcherFailure = error;
         browserRuntimeMutations.add(`anchor-watch-error:${error.message}`);
       });
       browserRuntimeWatchers.push(anchorWatcher);
@@ -2065,6 +2071,7 @@ export class PlaywrightHtmlOverlayRenderer implements HtmlOverlayRenderer {
             // its exact path identity still detects fixture substitution.
             return;
           }
+          watcherVersion += 1;
           if (path === runtimeName || path.startsWith(`${runtimeName}/`)) {
             browserRuntimeMutations.add(`${eventType}:${path}`);
             return;
@@ -2073,41 +2080,48 @@ export class PlaywrightHtmlOverlayRenderer implements HtmlOverlayRenderer {
         },
       );
       containerWatcher.on("error", error => {
+        watcherFailure = error;
         browserRuntimeMutations.add(`watch-error:${error.message}`);
       });
       browserRuntimeWatchers.push(containerWatcher);
-      await new Promise<void>(resolve => setTimeout(resolve, 25));
-      if (signal.aborted) throw cancellationReason(signal);
-      // FSEvents can deliver the just-created direct-child notification after
-      // both watches attach. Clear that bounded baseline before re-verifying
-      // every manifest and path identity. A swap during this window changes
-      // the already-captured container ctime and therefore fails below.
-      browserRuntimeMutations.clear();
       let browser: Browser | undefined;
       let browserFailure: Readonly<{ error: unknown }> | undefined;
       try {
-        await verifyBrowserRuntimeSnapshot(
-          preparedBrowserRuntime,
-          request.browserRuntime,
-          "immediately before launch",
-          signal,
-        );
-        await assertBrowserRuntimeSnapshotIdentity(
-          preparedBrowserRuntime,
-          request.browserRuntime.manifest.entries,
-          "immediately before launch",
-          signal,
-        );
-        await assertBrowserRuntimeSnapshotContainerIdentity(
-          preparedBrowserRuntime,
-          "immediately before launch",
+        // Delayed preparation notifications can arrive during full verification.
+        // Recheck the SAME pre-wait identities until one pass is stable. Nothing
+        // after the synchronous baseline commit is discarded.
+        await verifyStableBrowserWatcherBaseline({
           signal,
-        );
-        await assertBrowserRuntimeSnapshotAnchorIdentity(
-          preparedBrowserRuntime,
-          "immediately before launch",
-          signal,
-        );
+          version: () => watcherVersion,
+          failure: () => watcherFailure,
+          quietMs: process.platform === "darwin" ? 2_000 : 25,
+          deadlineMs: 10_000,
+          verify: async () => {
+            await verifyBrowserRuntimeSnapshot(
+              preparedBrowserRuntime,
+              request.browserRuntime,
+              "immediately before launch",
+              signal,
+            );
+            await assertBrowserRuntimeSnapshotIdentity(
+              preparedBrowserRuntime,
+              request.browserRuntime.manifest.entries,
+              "immediately before launch",
+              signal,
+            );
+            await assertBrowserRuntimeSnapshotContainerIdentity(
+              preparedBrowserRuntime,
+              "immediately before launch",
+              signal,
+            );
+            await assertBrowserRuntimeSnapshotAnchorIdentity(
+              preparedBrowserRuntime,
+              "immediately before launch",
+              signal,
+            );
+          },
+          commit: () => { browserRuntimeMutations.clear(); },
+        });
         discardProvenLaunchManagedRootMetadataEvent(
           browserRuntimeMutations,
           runtimeName,

package/apps/desktop/cli/html-overlay-watcher-baseline.ts

@@ -0,0 +1,65 @@
+import { setTimeout as delay } from "node:timers/promises";
+
+interface BaselineClock {
+  readonly now: () => number;
+  readonly wait: (milliseconds: number, signal: AbortSignal) => Promise<void>;
+}
+
+const clock: BaselineClock = {
+  now: () => performance.now(),
+  wait: async (milliseconds, signal) => { await delay(milliseconds, undefined, { signal }); },
+};
+
+/** Drain asynchronous preparation notifications before revalidating the saved identities. */
+interface BrowserWatcherBaselineOptions {
+  readonly signal: AbortSignal;
+  readonly version: () => number;
+  readonly failure: () => Error | undefined;
+  readonly quietMs: number;
+  readonly deadlineMs: number;
+  readonly clock?: BaselineClock;
+}
+
+export async function settleBrowserWatcherBaseline(options: BrowserWatcherBaselineOptions): Promise<void> {
+  const timing = options.clock ?? clock;
+  const started = timing.now();
+  let lastActivity = started;
+  let observedVersion = options.version();
+  for (;;) {
+    options.signal.throwIfAborted();
+    const failure = options.failure();
+    if (failure !== undefined) throw failure;
+    const now = timing.now();
+    const version = options.version();
+    if (version !== observedVersion) {
+      observedVersion = version;
+      lastActivity = now;
+    }
+    if (now - started >= options.deadlineMs) {
+      throw new Error("Browser runtime filesystem notifications did not settle before launch.");
+    }
+    if (now - lastActivity >= options.quietMs) return;
+    await timing.wait(Math.min(50, options.quietMs - (now - lastActivity), options.deadlineMs - (now - started)), options.signal);
+  }
+}
+
+/** Every discarded notification batch must precede a stable, complete identity check. */
+export async function verifyStableBrowserWatcherBaseline(options: BrowserWatcherBaselineOptions & {
+  readonly verify: () => Promise<void>;
+  readonly commit: () => void;
+}): Promise<void> {
+  for (let pass = 0; pass < 3; pass += 1) {
+    await settleBrowserWatcherBaseline(options);
+    const version = options.version();
+    await options.verify();
+    options.signal.throwIfAborted();
+    const failure = options.failure();
+    if (failure !== undefined) throw failure;
+    if (options.version() === version) {
+      // No await may separate the stable-generation check from arming the guard.
+      options.commit();
+      return;
+    }
+  }
+  throw new Error("Browser runtime filesystem notifications changed during all three verification passes.");
+}