@notis_ai/cli 0.2.0-beta.155.1 → 0.2.0-beta.157.1

package/template/packages/sdk/src/hooks/useTopBarSearch.ts

@@ -1,6 +1,6 @@
 'use client';
 
-import { useCallback, useEffect } from 'react';
+import { useCallback, useEffect, useLayoutEffect, useRef } from 'react';
 import { useNotisRuntime } from '../provider';
 
 interface TopBarSearchOptions {
@@ -24,8 +24,9 @@ interface TopBarSearchActions {
  * While the component is mounted, typing in the top bar calls `onChange`,
  * pressing Enter calls `onSubmit`, and the `value` prop drives the input.
  *
- * Call `setLoading(true)` to show the standard spinner in the top bar while a
- * query is running; `setLoading(false)` restores the search icon.
+ * Use `setLoading(true)` only for an explicitly submitted search action, then
+ * restore the icon with `setLoading(false)`. Automatic reads use content
+ * skeletons initially and refresh populated content silently.
  *
  * Without a portal runtime, this hook is a safe no-op.
  *
@@ -42,21 +43,28 @@ interface TopBarSearchActions {
  * });
  * ```
  *
- * Stabilize `onChange` and `onSubmit` with `useCallback` to avoid re-registering
- * on every render.
+ * Callback refs retain the latest committed handlers without re-registering
+ * search on every app render. Inline callbacks are safe.
  */
 export function useTopBarSearch(opts: TopBarSearchOptions): TopBarSearchActions {
   const runtime = useNotisRuntime();
   const { value, onChange, placeholder, onSubmit } = opts;
+  const callbacks = useRef({ onChange, onSubmit });
+  useLayoutEffect(() => { callbacks.current = { onChange, onSubmit }; });
+  const hasSubmit = Boolean(onSubmit);
 
   useEffect(() => {
     const register = runtime?.registerTopBarSearch;
     if (!register) return;
-    register({ onChange, placeholder, onSubmit });
+    register({
+      onChange: (next) => callbacks.current.onChange(next),
+      placeholder,
+      onSubmit: hasSubmit ? () => callbacks.current.onSubmit?.() : undefined,
+    });
     return () => {
       register(null);
     };
-  }, [runtime, onChange, placeholder, onSubmit]);
+  }, [runtime, placeholder, hasSubmit]);
 
   useEffect(() => {
     runtime?.setTopBarSearchValue?.(value);

package/template/packages/sdk/src/index.ts

@@ -10,6 +10,10 @@
 export { NotisProvider, useNotisRuntime } from './provider';
 
 // Hooks
+export { useQuery, useQueryClient } from './hooks/useQuery';
+export type { UseQueryOptions, UseQueryResult } from './hooks/useQuery';
+export { createQueryClient, createPrefetchQueue, queryKey } from './queryCache';
+export type { NotisQueryClient, QuerySnapshot, QueryFetchOptions } from './queryCache';
 export { useNotis } from './hooks/useNotis';
 export { useDocuments } from './hooks/useDocuments';
 export type { UseDocumentsOptions, UseDocumentsResult } from './hooks/useDocuments';
@@ -143,3 +147,7 @@ export type {
   ToolCallOptions,
   ToolInputSchema,
 } from './runtime';
+
+export { useToolQuery } from './hooks/useToolQuery';
+
+export { Skeleton, ViewSkeleton } from './components/Skeleton';

package/template/packages/sdk/src/interactions.ts

@@ -29,7 +29,8 @@ export type {
   SelectionMarqueeRect,
   UseCollectionInteractionsOptions,
 } from './hooks/useCollectionInteractions';
-export { MultiSelectActionBar } from './components/MultiSelectActionBar';
+export { MultiSelectActionBar, BULK_ACTION_LAYOUT_EVENT } from './components/MultiSelectActionBar';
+export type { BulkActionLayoutDetail } from './components/MultiSelectActionBar';
 export { MultiSelectCheckbox, MultiSelectCheckbox as SelectionCheckbox } from './components/MultiSelectCheckbox';
 export { MultiSelectDragOverlay, MultiSelectDragOverlay as SelectionMarquee } from './components/MultiSelectDragOverlay';
 export { ShortcutHints } from './components/ShortcutHints';

package/template/packages/sdk/src/queryCache.ts

@@ -0,0 +1,162 @@
+/** In-memory read snapshots. The host owns the lifetime and authorization scope. */
+export interface QuerySnapshot<T = unknown> {
+  data: T | undefined;
+  hasData: boolean;
+  isFetching: boolean;
+  error: Error | null;
+  updatedAt: number;
+  invalidation: number;
+}
+
+export interface QueryFetchOptions {
+  staleTimeMs?: number;
+  force?: boolean;
+}
+
+export interface NotisQueryClient {
+  getSnapshot<T>(key: string): QuerySnapshot<T>;
+  subscribe(key: string, listener: () => void): () => void;
+  fetch<T>(key: string, read: () => Promise<T>, options?: QueryFetchOptions): Promise<T>;
+  prefetch<T>(key: string, read: () => Promise<T>, options?: QueryFetchOptions): Promise<T>;
+  invalidate(key?: string): void;
+  clear(): void;
+  /** Host-only: permanently retire a revoked security scope. */
+  dispose?(): void;
+  getRevision?(): number;
+}
+
+const EMPTY: QuerySnapshot = Object.freeze({
+  data: undefined, hasData: false, isFetching: false, error: null, updatedAt: 0, invalidation: 0,
+});
+
+/** Stable keys distinguish filters, pagination, and resource identities. */
+export function queryKey(value: unknown): string {
+  if (value instanceof Date) return JSON.stringify(value.toISOString());
+  if (Array.isArray(value)) return `[${value.map(queryKey).join(',')}]`;
+  if (value && typeof value === 'object') {
+    const record = value as Record<string, unknown>;
+    return `{${Object.keys(record).filter((key) => record[key] !== undefined).sort()
+      .map((key) => `${JSON.stringify(key)}:${queryKey(record[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value) ?? 'null';
+}
+
+/** One shared queue can bound descriptor and data speculation together. */
+export function createPrefetchQueue(concurrency = 2) {
+  let active = 0;
+  const waiting: Array<() => void> = [];
+  function drain() {
+    while (active < concurrency && waiting.length) waiting.shift()!();
+  }
+  return <T>(read: () => Promise<T>): Promise<T> => new Promise<T>((resolve, reject) => {
+    waiting.push(() => {
+      active += 1;
+      Promise.resolve().then(read).then(resolve, reject).finally(() => { active -= 1; drain(); });
+    });
+    drain();
+  });
+}
+
+type Entry = {
+  snapshot: QuerySnapshot;
+  listeners: Set<() => void>;
+  generation: number;
+  pending?: Promise<unknown>;
+};
+
+export function createQueryClient(options: {
+  maxEntries?: number;
+  now?: () => number;
+  schedule?: ReturnType<typeof createPrefetchQueue>;
+} = {}): NotisQueryClient {
+  const entries = new Map<string, Entry>();
+  const now = options.now ?? Date.now;
+  const maxEntries = options.maxEntries ?? 100;
+  const schedule = options.schedule ?? createPrefetchQueue(2);
+  let epoch = 0;
+  let disposed = false;
+  let revision = 0;
+
+  function prune(keep?: string) {
+    for (const [oldKey, old] of entries) {
+      if (entries.size <= maxEntries) break;
+      if (oldKey !== keep && !old.listeners.size && !old.pending) entries.delete(oldKey);
+    }
+  }
+  function entry(key: string): Entry {
+    let value = entries.get(key);
+    if (!value) {
+      value = { snapshot: EMPTY, listeners: new Set(), generation: 0 };
+      entries.set(key, value);
+    }
+    // Only operations, not getSnapshot during render, update the LRU.
+    entries.delete(key);
+    entries.set(key, value);
+    prune(key);
+    return value;
+  }
+  function publish(value: Entry, snapshot: QuerySnapshot) {
+    value.snapshot = snapshot;
+    for (const listener of value.listeners) listener();
+  }
+  const client: NotisQueryClient = {
+    getSnapshot<T>(key: string) { return (entries.get(key)?.snapshot ?? EMPTY) as QuerySnapshot<T>; },
+    subscribe(key, listener) {
+      const value = entry(key);
+      value.listeners.add(listener);
+      return () => { value.listeners.delete(listener); prune(); };
+    },
+    fetch<T>(key: string, read: () => Promise<T>, fetchOptions: QueryFetchOptions = {}) {
+      if (disposed) return Promise.reject(new Error('App query scope is no longer available.'));
+      const value = entry(key);
+      if (value.pending) return value.pending as Promise<T>;
+      if (!fetchOptions.force && value.snapshot.hasData && value.snapshot.updatedAt > 0
+        && now() - value.snapshot.updatedAt < (fetchOptions.staleTimeMs ?? 30_000)) {
+        return Promise.resolve(value.snapshot.data as T);
+      }
+      const generation = ++value.generation;
+      const requestEpoch = epoch;
+      const canCommit = () => epoch === requestEpoch && value.generation === generation && entries.get(key) === value;
+      const request = Promise.resolve().then(read).then((data) => {
+        if (canCommit()) publish(value, { ...value.snapshot, data, hasData: true, isFetching: false, error: null, updatedAt: now() });
+        return data;
+      }, (reason) => {
+        const error = reason instanceof Error ? reason : new Error(String(reason));
+        if (canCommit()) publish(value, { ...value.snapshot, isFetching: false, error });
+        throw error;
+      }).finally(() => { if (value.pending === request) value.pending = undefined; prune(); });
+      value.pending = request;
+      publish(value, { ...value.snapshot, isFetching: true, error: null });
+      return request;
+    },
+    prefetch<T>(key: string, read: () => Promise<T>, fetchOptions?: QueryFetchOptions) {
+      const requestEpoch = epoch;
+      return schedule(() => {
+        if (epoch !== requestEpoch) throw new Error('App query scope was cleared.');
+        return client.fetch(key, read, fetchOptions);
+      });
+    },
+    getRevision: () => revision,
+    invalidate(key) {
+      revision += 1;
+      for (const [entryKey, value] of entries) {
+        if (key !== undefined && entryKey !== key) continue;
+        value.generation += 1;
+        value.pending = undefined;
+        publish(value, { ...value.snapshot, updatedAt: 0, isFetching: false, invalidation: value.snapshot.invalidation + 1 });
+      }
+    },
+    dispose() { disposed = true; client.clear(); },
+    clear() {
+      revision += 1;
+      epoch += 1;
+      for (const value of entries.values()) {
+        value.generation += 1;
+        value.pending = undefined;
+        publish(value, { ...EMPTY, invalidation: value.snapshot.invalidation + 1 });
+      }
+      for (const [key, value] of entries) if (!value.listeners.size) entries.delete(key);
+    },
+  };
+  return client;
+}

package/template/packages/sdk/src/runtime.ts

@@ -8,6 +8,7 @@
  */
 
 import type { ComponentType } from 'react';
+import type { NotisQueryClient } from './queryCache';
 
 // ---------------------------------------------------------------------------
 // Database types
@@ -106,6 +107,8 @@ export interface ToolDescriptor {
 }
 
 export interface ToolCallOptions {
+  /** Explicitly identifies an idempotent read; never set on a mutation. */
+  readOnly?: boolean;
   /**
    * Coalesce an identical in-flight call. Only opt in for idempotent reads;
    * mutations must execute once per invocation.
@@ -359,6 +362,8 @@ export interface CloudComputerFacts {
 }
 
 export interface NotisRuntime {
+  /** Optional host-scoped in-memory read cache. Older hosts remain supported. */
+  queryClient?: NotisQueryClient;
   app: AppDescriptor;
   route: RouteDescriptor;
   databases: DatabaseDescriptor[];

package/template/packages/sdk/src/styles.css

@@ -28,8 +28,35 @@
     @apply mx-auto w-full max-w-[var(--portal-page-max-width)] px-4 py-6 md:px-4 md:py-8;
   }
 
+  /* Flat panel. No border, no shadow: the design bar allows a single hairline
+   * between sections and nothing around items. */
   .notis-app-surface {
-    @apply rounded-2xl border border-border bg-card text-card-foreground shadow-sm;
+    @apply rounded-2xl bg-muted text-card-foreground;
+  }
+
+  /* List rows: hover and selection are carried by background tint only. Rows
+   * read as tinted panels on mobile and as transparent rows on desktop. */
+  .list-row {
+    @apply rounded-xl bg-muted px-4 py-3 transition-colors lg:bg-transparent lg:hover:bg-muted/60;
+  }
+
+  .list-row-selected {
+    @apply bg-primary/[0.06] lg:bg-primary/[0.06] lg:hover:bg-primary/[0.06];
+  }
+
+  /* Split (list + detail) pages are full-bleed: use these instead of
+   * .notis-app-shell. The list pane is tinted and carries the one allowed
+   * hairline; the detail pane sits on the plain background. */
+  .notis-app-split {
+    @apply flex h-full min-h-0 w-full max-w-none flex-col lg:flex-row;
+  }
+
+  .notis-app-pane-list {
+    @apply w-full shrink-0 bg-muted/40 lg:w-80 lg:border-r lg:border-border xl:w-96;
+  }
+
+  .notis-app-pane-detail {
+    @apply min-w-0 flex-1 bg-background;
   }
 
   .notis-app-section {

package/src/runtime/app-dev-build-supervisor.js

@@ -1,47 +0,0 @@
-// A separate process retains ownership of the build group if the CLI crashes.
-// IPC disconnect is the lifetime signal; unlike polling a PID it cannot mistake
-// a reused PID for the original owner.
-import { spawn } from 'node:child_process';
-
-if (!process.send) throw new Error('Build supervisor requires an IPC owner');
-let build;
-let stopping = false;
-function stop(code = 0) {
-  if (stopping) return;
-  stopping = true;
-  if (!build?.pid) process.exit(code);
-  if (process.platform === 'win32') {
-    const killer = spawn('taskkill', ['/pid', String(build.pid), '/t', '/f']);
-    killer.once('error', () => process.exit(1));
-    killer.once('exit', () => process.exit(code));
-    return;
-  }
-  const signalGroup = (signal) => {
-    try { process.kill(-build.pid, signal); } catch (error) {
-      if (error.code !== 'ESRCH') throw error;
-    }
-  };
-  signalGroup('SIGTERM');
-  // npm can exit before Vite/esbuild. Keep the supervisor alive until the
-  // entire group has received the fallback signal.
-  setTimeout(() => {
-    signalGroup('SIGKILL');
-    process.exit(code);
-  }, 1000);
-}
-process.on('disconnect', () => stop());
-process.on('SIGTERM', () => stop());
-process.on('SIGINT', () => stop());
-process.once('message', ({ command, args }) => {
-  if (stopping || !process.connected) return;
-  build = spawn(command, args, {
-    detached: process.platform !== 'win32',
-    stdio: 'inherit',
-    env: process.env,
-  });
-  build.once('spawn', () => {
-    if (process.connected) process.send({ pid: build.pid }, () => {});
-  });
-  build.once('error', () => stop(1));
-  build.once('exit', (code) => stop(code || 0));
-});

package/src/runtime/app-dev-build.js

@@ -1,41 +0,0 @@
-import { spawn } from 'node:child_process';
-import { EventEmitter } from 'node:events';
-import { fileURLToPath } from 'node:url';
-
-// Expose the actual npm group identity so Desktop recovery and diagnostics
-// retain their existing ownership contract. The supervisor owns its lifetime.
-export async function startAppDevBuild(cwd, command = 'npm', args = ['run', 'build', '--', '--watch']) {
-  const supervisor = spawn(process.execPath, [fileURLToPath(new URL('./app-dev-build-supervisor.js', import.meta.url))], {
-    cwd,
-    stdio: ['ignore', 'inherit', 'inherit', 'ipc'],
-    env: { ...process.env, ELECTRON_RUN_AS_NODE: '1', NOTIS_DEV: '1' },
-  });
-  const build = new EventEmitter();
-  build.pid = null;
-  build.exitCode = null;
-  build.signalCode = null;
-  build.kill = (signal = 'SIGTERM') => supervisor.kill(signal);
-  await new Promise((resolve, reject) => {
-    supervisor.once('error', reject);
-    supervisor.once('exit', (code, signal) => {
-      build.exitCode = code;
-      build.signalCode = signal;
-      reject(new Error(`Build supervisor exited before startup (${code ?? signal})`));
-      build.emit('exit', code, signal);
-    });
-    supervisor.once('message', ({ pid }) => {
-      build.pid = pid;
-      resolve();
-    });
-    supervisor.send({ command, args }, (error) => { if (error) reject(error); });
-  });
-  return build;
-}
-
-export async function stopAppDevBuild(build) {
-  if (!build || build.exitCode !== null || build.signalCode !== null) return;
-  await new Promise((resolve) => {
-    build.once('exit', resolve);
-    build.kill('SIGTERM');
-  });
-}

package/src/runtime/app-dev-consumers.js

@@ -1,154 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import {
-  existsSync,
-  lstatSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  rmSync,
-  writeFileSync,
-} from 'node:fs';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-
-export const DEFAULT_APP_DEV_CONSUMERS_FILE = join(homedir(), '.notis', 'app-dev-consumers.json');
-export const APP_DEV_CONSUMER_EXPIRES_AFTER_MS = 10_000;
-const waitArray = new Int32Array(new SharedArrayBuffer(4));
-const CONSUMER_LOCK_STALE_AFTER_MS = 30_000;
-
-function processIsRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error?.code !== 'ESRCH';
-  }
-}
-
-function reclaimConsumerLock(lockPath) {
-  const stat = lstatSync(lockPath);
-  if (!stat.isDirectory() || stat.isSymbolicLink()) {
-    throw new Error(`Refusing unsafe app development consumer lock: ${lockPath}`);
-  }
-  let ownerPid = null;
-  try {
-    const owner = readFileSync(join(lockPath, 'owner'), 'utf8').trim();
-    const parsed = Number.parseInt(owner.split('.')[0] || '', 10);
-    ownerPid = Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null;
-  } catch {
-    // An interrupted owner write is reclaimed after the bounded stale window.
-  }
-  if (ownerPid !== null) return !processIsRunning(ownerPid);
-  return Date.now() - stat.mtimeMs >= CONSUMER_LOCK_STALE_AFTER_MS;
-}
-
-function withLock(filePath, callback) {
-  mkdirSync(dirname(filePath), { recursive: true, mode: 0o700 });
-  const lockPath = `${filePath}.lock`;
-  const owner = `${process.pid}.${randomUUID()}`;
-  const startedAt = Date.now();
-  while (true) {
-    try {
-      mkdirSync(lockPath, { mode: 0o700 });
-      writeFileSync(join(lockPath, 'owner'), owner, { mode: 0o600 });
-      break;
-    } catch (error) {
-      if (error?.code !== 'EEXIST') throw error;
-      try {
-        if (reclaimConsumerLock(lockPath)) {
-          rmSync(lockPath, { recursive: true, force: true });
-          continue;
-        }
-      } catch (lockError) {
-        if (lockError?.code === 'ENOENT') continue;
-        throw lockError;
-      }
-      if (Date.now() - startedAt > 2_000) {
-        throw new Error('App development consumer registry is busy.');
-      }
-      Atomics.wait(waitArray, 0, 0, 10);
-    }
-  }
-  try {
-    return callback();
-  } finally {
-    try {
-      if (readFileSync(join(lockPath, 'owner'), 'utf8').trim() === owner) {
-        rmSync(lockPath, { recursive: true, force: true });
-      }
-    } catch {
-      // A replaced lock belongs to another writer.
-    }
-  }
-}
-
-function normalize(value, now) {
-  const raw = value && typeof value === 'object' && Array.isArray(value.consumers)
-    ? value.consumers
-    : [];
-  return raw.filter((lease) => {
-    const heartbeat = Date.parse(String(lease?.lastHeartbeatAt || ''));
-    return typeof lease?.instanceId === 'string'
-      && typeof lease?.userId === 'string'
-      && typeof lease?.apiBase === 'string'
-      && Number.isSafeInteger(lease?.pid)
-      && Number.isFinite(heartbeat)
-      && now - heartbeat <= APP_DEV_CONSUMER_EXPIRES_AFTER_MS;
-  });
-}
-
-export function readAppDevConsumers(filePath = DEFAULT_APP_DEV_CONSUMERS_FILE, now = Date.now()) {
-  if (!existsSync(filePath)) return [];
-  try {
-    return normalize(JSON.parse(readFileSync(filePath, 'utf8')), now);
-  } catch {
-    return [];
-  }
-}
-
-function writeAppDevConsumers(filePath, consumers) {
-  mkdirSync(dirname(filePath), { recursive: true, mode: 0o700 });
-  const temporary = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
-  writeFileSync(temporary, JSON.stringify({ version: 1, consumers }, null, 2), { mode: 0o600 });
-  renameSync(temporary, filePath);
-}
-
-export function heartbeatAppDevConsumer(
-  lease,
-  filePath = DEFAULT_APP_DEV_CONSUMERS_FILE,
-) {
-  return withLock(filePath, () => {
-    const now = Date.now();
-    const next = readAppDevConsumers(filePath, now)
-      .filter((entry) => entry.instanceId !== lease.instanceId);
-    next.push({
-      ...lease,
-      apiBase: lease.apiBase.replace(/\/$/, ''),
-      lastHeartbeatAt: new Date(now).toISOString(),
-    });
-    writeAppDevConsumers(filePath, next);
-    return next;
-  });
-}
-
-export function removeAppDevConsumer(
-  instanceId,
-  filePath = DEFAULT_APP_DEV_CONSUMERS_FILE,
-) {
-  return withLock(filePath, () => {
-    const next = readAppDevConsumers(filePath)
-      .filter((entry) => entry.instanceId !== instanceId);
-    writeAppDevConsumers(filePath, next);
-    return next;
-  });
-}
-
-export function hasAppDevConsumer(consumers, { mode, userId, apiBase }) {
-  if (mode === 'machine') return consumers.length > 0;
-  if (mode !== 'environment') return true;
-  const normalizedApiBase = String(apiBase || '').replace(/\/$/, '');
-  return consumers.some((consumer) => (
-    consumer.userId === userId
-    && consumer.apiBase.replace(/\/$/, '') === normalizedApiBase
-  ));
-}

package/src/runtime/app-dev-host-lock.js

@@ -1,80 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { lstatSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-
-const DEFAULT_LOCK_ROOT = join(homedir(), '.notis', 'app-dev-host-locks');
-const OWNER_FILE = 'owner.json';
-
-function processIsRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error?.code !== 'ESRCH';
-  }
-}
-
-function lockName(identity, apiBase, projectDir) {
-  return createHash('sha256').update(`${identity}\0${apiBase}\0${projectDir}`).digest('hex');
-}
-
-function readOwner(path) {
-  try {
-    const value = JSON.parse(readFileSync(join(path, OWNER_FILE), 'utf8'));
-    return Number.isSafeInteger(value?.pid) && typeof value?.ownerId === 'string'
-      ? { pid: value.pid, ownerId: value.ownerId }
-      : null;
-  } catch {
-    return null;
-  }
-}
-
-function reclaimable(path, now, staleAfterMs) {
-  const stat = lstatSync(path);
-  if (!stat.isDirectory() || stat.isSymbolicLink()) {
-    throw new Error(`Refusing unsafe app development host lock: ${path}`);
-  }
-  const owner = readOwner(path);
-  if (owner) return !processIsRunning(owner.pid);
-  return now - stat.mtimeMs >= staleAfterMs;
-}
-
-export function tryAcquireAppDevHostLock(options) {
-  const lockRoot = options.lockRoot || DEFAULT_LOCK_ROOT;
-  mkdirSync(lockRoot, { recursive: true, mode: 0o700 });
-  const path = join(lockRoot, lockName(options.identity, options.apiBase, options.projectDir));
-  const ownerId = `${process.pid}.${randomUUID()}`;
-  for (let attempt = 0; attempt < 2; attempt += 1) {
-    try {
-      mkdirSync(path, { mode: 0o700 });
-      try {
-        writeFileSync(join(path, OWNER_FILE), JSON.stringify({ pid: process.pid, ownerId }), {
-          mode: 0o600,
-        });
-      } catch (error) {
-        rmSync(path, { recursive: true, force: true });
-        throw error;
-      }
-      return { path, ownerId };
-    } catch (error) {
-      if (error?.code !== 'EEXIST') throw error;
-      if (reclaimable(path, options.now ?? Date.now(), options.staleAfterMs ?? 60_000)) {
-        rmSync(path, { recursive: true, force: true });
-        continue;
-      }
-      return null;
-    }
-  }
-  return null;
-}
-
-export function releaseAppDevHostLock(lock) {
-  try {
-    if (readOwner(lock.path)?.ownerId === lock.ownerId) {
-      rmSync(lock.path, { recursive: true, force: true });
-    }
-  } catch {
-    // A replaced lock belongs to another process.
-  }
-}