@notis_ai/cli 0.2.0-beta.19.1 → 0.2.0-beta.196.1

package/src/runtime/transport.js

@@ -1,37 +1,96 @@
 import { randomUUID } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import { dirname } from 'node:path';
 import { CliError, EXIT_CODES } from './errors.js';
+import { delegatedContextReason } from './delegated-context.js';
+import {
+  credentialIsExpired,
+  getJwtExpiration,
+  getJwtSubject,
+  getProfile,
+  isJwtExpired,
+  loadConfig,
+  resolveWorktreeRuntime,
+} from './profiles.js';
+import { createExpiredAuthError, createInvalidAuthHints } from './auth-recovery.js';
+import { refreshOAuthCredential } from './oauth.js';
 
-const META_TOOL_NAMES = new Set([
-  'notis_find_toolkits',
-  'notis_find_tools',
-  'notis_execute_tool',
-  'notis_find_additional_tools',
-]);
+function escapeMultipartHeaderValue(value) {
+  return String(value ?? '')
+    .replace(/"/g, '%22')
+    .replace(/\r/g, '%0D')
+    .replace(/\n/g, '%0A');
+}
 
-function canonicalizeToolName(toolName) {
-  if (typeof toolName !== 'string' || !toolName.length) {
-    return toolName;
-  }
+function multipartTextPart(boundary, name, value) {
+  return [
+    `--${boundary}`,
+    `Content-Disposition: form-data; name="${escapeMultipartHeaderValue(name)}"`,
+    '',
+    value,
+    '',
+  ].join('\r\n');
+}
 
-  if (META_TOOL_NAMES.has(toolName) || toolName.startsWith('notis-default-')) {
-    return toolName;
-  }
+function multipartFileHeader(boundary, binding) {
+  const filename = escapeMultipartHeaderValue(binding.basename || binding.field_name);
+  return [
+    `--${boundary}`,
+    `Content-Disposition: form-data; name="${escapeMultipartHeaderValue(binding.field_name)}"; filename="${filename}"`,
+    `Content-Type: ${binding.contentType || 'application/octet-stream'}`,
+    '',
+    '',
+  ].join('\r\n');
+}
 
-  if (toolName.startsWith('notis_')) {
-    return `notis-default-${toolName.slice('notis_'.length)}`;
+async function* multipartFileBody(boundary, payload, bindingMetadata, fileBindings) {
+  yield Buffer.from(multipartTextPart(boundary, 'payload', JSON.stringify(payload)));
+  yield Buffer.from(multipartTextPart(boundary, 'file_bindings', JSON.stringify(bindingMetadata)));
+  for (const binding of fileBindings) {
+    yield Buffer.from(multipartFileHeader(boundary, binding));
+    for await (const chunk of createReadStream(binding.localPath)) {
+      yield chunk;
+    }
+    yield Buffer.from('\r\n');
   }
+  yield Buffer.from(`--${boundary}--\r\n`);
+}
 
-  if (toolName.includes('_notis_')) {
-    return `notis-default-${toolName.replace(/_notis_/g, '_')}`;
-  }
+function createMultipartFileUpload(payload, bindingMetadata, fileBindings) {
+  const boundary = `----notis-cli-${randomUUID().replace(/-/g, '')}`;
+  const textParts = [
+    multipartTextPart(boundary, 'payload', JSON.stringify(payload)),
+    multipartTextPart(boundary, 'file_bindings', JSON.stringify(bindingMetadata)),
+  ];
+  const fileHeaderParts = fileBindings.map((binding) => multipartFileHeader(boundary, binding));
+  const closingPart = `--${boundary}--\r\n`;
+  const contentLength = [
+    ...textParts,
+    ...fileHeaderParts,
+    ...fileBindings.map(() => '\r\n'),
+    closingPart,
+  ].reduce((total, part) => total + Buffer.byteLength(part), 0)
+    + fileBindings.reduce((total, binding) => total + binding.size, 0);
 
-  return toolName;
+  return {
+    body: multipartFileBody(boundary, payload, bindingMetadata, fileBindings),
+    headers: {
+      'Content-Type': `multipart/form-data; boundary=${boundary}`,
+      'Content-Length': String(contentLength),
+    },
+    duplex: 'half',
+  };
 }
 
-function normalizeBackendError(status, payload) {
+export function normalizeBackendError(status, payload, runtime) {
   const backendError = payload?.error;
+  // Space errors answer {error: <stable code>, message: <readable text>}: show
+  // the text (it can name the Space involved); the code stays in details.
+  const codedMessage = typeof backendError === 'string' && /^[a-z][a-z0-9_]*$/.test(backendError)
+    && typeof payload?.message === 'string' && payload.message ? payload.message : null;
   const message =
     backendError?.message ||
+    codedMessage ||
     backendError ||
     payload?.message ||
     payload?.error ||
@@ -43,10 +102,7 @@ function normalizeBackendError(status, payload) {
       message,
       exitCode: EXIT_CODES.auth,
       hints: [
-        {
-          command: 'notis auth login --jwt <token>',
-          reason: 'Refresh the stored JWT for this profile',
-        },
+        ...createInvalidAuthHints(runtime),
       ],
       details: payload || {},
     });
@@ -77,6 +133,18 @@ function normalizeBackendError(status, payload) {
     });
   }
 
+  if (status === 402) {
+    // Distinct from auth on purpose: an agent that sees an auth exit code will
+    // loop trying to re-authenticate, when the actual fix is to add credit.
+    return new CliError({
+      code: 'payment_required',
+      message,
+      exitCode: EXIT_CODES.payment,
+      details: payload || {},
+      hints: payload?.hints || [],
+    });
+  }
+
   if (status >= 400 && status < 500) {
     return new CliError({
       code: 'usage_error',
@@ -97,45 +165,235 @@ function normalizeBackendError(status, payload) {
   });
 }
 
+/**
+ * Pick up a dev credential that `./dev.sh` re-minted mid-process.
+ *
+ * Restarting the local runtime rewrites the worktree lease in place, so a
+ * long-running command can recover from a single 401 instead of failing and
+ * making the caller rerun it. The refreshed token still has to belong to the
+ * worktree's approved test user.
+ */
+function reloadDevJwt(runtime, loadedProfile = null) {
+  if (runtime.credentialKind !== 'worktree') {
+    return false;
+  }
+  let nextJwt = null;
+  const expectedUserId = runtime.worktreeRuntime?.expected_user_id;
+  const runtimePath = runtime.worktreeRuntime?.runtime_path;
+  if (runtimePath) {
+    const refreshedRuntime = resolveWorktreeRuntime(dirname(runtimePath));
+    if (
+      refreshedRuntime
+      && !refreshedRuntime.unavailable
+      && refreshedRuntime.runtime_path === runtimePath
+      && refreshedRuntime.profile === runtime.profileName
+      && refreshedRuntime.api_base === runtime.apiBase
+    ) {
+      if (
+        expectedUserId
+        && refreshedRuntime.expected_user_id !== expectedUserId
+      ) {
+        throw new CliError({
+          code: 'dev_runtime_identity_mismatch',
+          message: 'The restarted worktree runtime belongs to a different test user',
+          exitCode: EXIT_CODES.auth,
+          hints: [
+            { message: 'Restart this CLI command under the worktree\'s current dev identity.' },
+            { message: `Expected user: ${expectedUserId}` },
+          ],
+        });
+      }
+      runtime.worktreeRuntime = refreshedRuntime;
+      nextJwt = refreshedRuntime.dev_access_token;
+    }
+  }
+  let profile = loadedProfile;
+  if (!nextJwt && !profile) {
+    try {
+      profile = getProfile(loadConfig(), runtime.profileName);
+    } catch {
+      return false;
+    }
+  }
+  nextJwt = nextJwt || (
+    typeof profile?.dev_access_token === 'string' && profile.dev_access_token
+      ? profile.dev_access_token
+      : null
+  );
+  if (!nextJwt || nextJwt === runtime.jwt) {
+    return false;
+  }
+  if (expectedUserId && getJwtSubject(nextJwt) !== expectedUserId) {
+    throw new CliError({
+      code: 'dev_runtime_identity_mismatch',
+      message: 'The refreshed dev credential does not belong to this worktree test user',
+      exitCode: EXIT_CODES.auth,
+      hints: [
+        { message: 'Restart ./dev.sh to restore the approved worktree identity.' },
+        { message: `Expected user: ${expectedUserId}` },
+      ],
+    });
+  }
+  runtime.jwt = nextJwt;
+  return true;
+}
+
+/**
+ * A live worktree lease is authoritative over any stale dev metadata left in
+ * the shared profile store. Prefer its explicit expiry, then the active JWT's
+ * expiry, and deliberately fail closed when neither can be verified.
+ */
+export function getActiveWorktreeCredentialProfile(runtime, loadedProfile = {}) {
+  if (runtime.credentialKind !== 'worktree') {
+    return loadedProfile;
+  }
+  return {
+    ...loadedProfile,
+    dev_access_expires_at:
+      runtime.worktreeRuntime?.dev_access_expires_at
+      ?? getJwtExpiration(runtime.jwt)
+      ?? loadedProfile.dev_access_expires_at,
+  };
+}
+
 export async function httpRequest({
   runtime,
   method = 'POST',
   path,
   body,
+  multipart = false,
   requireAuth = true,
+  spacesProtocol,
 }) {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), runtime.timeoutMs);
+  // Refresh before spending the credential rather than after a rejection: the
+  // rotating refresh token is shared with every other `notis` process reading
+  // the same profile, so a lapsed access token is renewed once, under the
+  // config write lock, instead of racing on a 401 retry.
+  let currentProfile;
+  if (runtime.credentialKind === 'oauth') {
+    if (requireAuth && credentialIsExpired(runtime, {
+      oauth_access_expires_at: runtime.oauthAccessExpiresAt,
+    })) {
+      await refreshOAuthCredential(runtime);
+    }
+    currentProfile = getProfile(loadConfig(), runtime.profileName);
+  } else {
+    currentProfile = getProfile(loadConfig(), runtime.profileName);
+    reloadDevJwt(runtime, currentProfile);
+    currentProfile = getActiveWorktreeCredentialProfile(runtime, currentProfile);
+  }
+  if (requireAuth && credentialIsExpired(runtime, currentProfile)) {
+    throw createExpiredAuthError(runtime);
+  }
+
+  let controller = new AbortController();
+  let timeout = setTimeout(() => controller.abort(), runtime.timeoutMs);
   const requestId = `req_${randomUUID().replace(/-/g, '')}`;
+  const resetTimeout = () => {
+    clearTimeout(timeout);
+    controller = new AbortController();
+    timeout = setTimeout(() => controller.abort(), runtime.timeoutMs);
+  };
 
   const headers = {
-    'Content-Type': 'application/json',
     'X-Notis-CLI-Version': runtime.cliVersion,
     'X-Notis-Request-Id': requestId,
   };
+  if (spacesProtocol !== undefined) headers['X-Notis-Spaces-Protocol'] = String(spacesProtocol);
+  if (!multipart) {
+    headers['Content-Type'] = 'application/json';
+  }
 
   if (requireAuth && runtime.jwt) {
     headers.Authorization = `Bearer ${runtime.jwt}`;
   }
 
+  const resolveBody = () => {
+    if (!multipart) {
+      return {
+        body: body ? JSON.stringify(body) : undefined,
+        headers: {},
+      };
+    }
+    if (typeof body === 'function') {
+      return body();
+    }
+    return {
+      body,
+      headers: {},
+    };
+  };
+
   try {
-    const response = await fetch(`${runtime.apiBase}${path}`, {
+    let requestBody = resolveBody();
+    let response = await fetch(`${runtime.apiBase}${path}`, {
       method,
-      headers,
-      body: body ? JSON.stringify(body) : undefined,
+      headers: { ...headers, ...requestBody.headers },
+      body: requestBody.body,
       signal: controller.signal,
+      ...(requestBody.duplex ? { duplex: requestBody.duplex } : {}),
     });
-    clearTimeout(timeout);
 
     let payload = null;
+    let payloadReadError = null;
     try {
       payload = await response.json();
-    } catch {
+    } catch (error) {
+      payloadReadError = error;
       payload = null;
     }
 
+    if (response.status === 401) {
+      const refreshed = runtime.credentialKind === 'oauth'
+        ? await refreshOAuthCredential(runtime)
+        : reloadDevJwt(runtime) && !isJwtExpired(runtime.jwt);
+      if (refreshed) {
+        if (requireAuth && runtime.jwt) {
+          headers.Authorization = `Bearer ${runtime.jwt}`;
+        }
+        resetTimeout();
+        requestBody = resolveBody();
+        response = await fetch(`${runtime.apiBase}${path}`, {
+          method,
+          headers: { ...headers, ...requestBody.headers },
+          body: requestBody.body,
+          signal: controller.signal,
+          ...(requestBody.duplex ? { duplex: requestBody.duplex } : {}),
+        });
+        payloadReadError = null;
+        try {
+          payload = await response.json();
+        } catch (error) {
+          payloadReadError = error;
+          payload = null;
+        }
+      }
+    }
+
+    clearTimeout(timeout);
+
     if (!response.ok) {
-      throw normalizeBackendError(response.status, payload);
+      if (
+        response.status === 401
+        && credentialIsExpired(
+          runtime,
+          getActiveWorktreeCredentialProfile(
+            runtime,
+            getProfile(loadConfig(), runtime.profileName),
+          ),
+        )
+      ) {
+        throw createExpiredAuthError(runtime);
+      }
+      throw normalizeBackendError(response.status, payload, runtime);
+    }
+
+    // A successful status is not a successful tool call until its response
+    // body has been read. Mutations may already have committed before a socket
+    // reset truncates the JSON; surface that as an ambiguous network failure
+    // so callers never persist an undefined result or attempt a second write.
+    if (response.status !== 204 && payloadReadError) {
+      throw payloadReadError;
     }
 
     return {
@@ -177,22 +435,50 @@ export async function callTool({
   toolName,
   arguments_: argumentsPayload = {},
   idempotencyKey,
+  fileBindings = [],
 }) {
   const requestId = idempotencyKey || (runtime.mutating ? randomUUID() : null);
+  const payload = {
+    tool_name: toolName,
+    arguments: argumentsPayload,
+    idempotency_key: requestId,
+    cli_context: {
+      output_mode: runtime.outputMode,
+      profile: runtime.profileName,
+      cwd: process.cwd(),
+      agent_mode: runtime.agentMode,
+      cli_version: runtime.cliVersion,
+      // Reported so the server can refuse work-handing tools from a run Notis
+      // is itself driving. Advisory -- a determined agent can unset the markers
+      // -- so the server treats it as one layer, not the whole guard.
+      ...(delegatedContextReason() ? { delegated_context: true } : {}),
+      ...(runtime.debugEntitlementOverride
+        ? { debug_entitlement_override: runtime.debugEntitlementOverride }
+        : {}),
+    },
+  };
+
+  if (Array.isArray(fileBindings) && fileBindings.length) {
+    const bindingMetadata = fileBindings.map((binding) => {
+      const {
+        contentType,
+        localPath,
+        ...metadata
+      } = binding;
+      return metadata;
+    });
+
+    return httpRequest({
+      runtime,
+      path: '/cli_tools',
+      body: () => createMultipartFileUpload(payload, bindingMetadata, fileBindings),
+      multipart: true,
+    });
+  }
+
   return httpRequest({
     runtime,
     path: '/cli_tools',
-    body: {
-      tool_name: canonicalizeToolName(toolName),
-      arguments: argumentsPayload,
-      idempotency_key: requestId,
-      cli_context: {
-        output_mode: runtime.outputMode,
-        profile: runtime.profileName,
-        cwd: process.cwd(),
-        agent_mode: runtime.agentMode,
-        cli_version: runtime.cliVersion,
-      },
-    },
+    body: payload,
   });
 }

package/src/runtime/view-render.js

@@ -0,0 +1,49 @@
+import { existsSync } from 'node:fs';
+import { mkdir, writeFile, unlink } from 'node:fs/promises';
+import { resolve, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { httpRequest } from './transport.js';
+import { CliError, EXIT_CODES, usageError } from './errors.js';
+
+async function rendererLibrary() {
+  const packaged = new URL('../../dist/view-renderer/src/index.js', import.meta.url);
+  if (existsSync(fileURLToPath(packaged))) return import(packaged.href);
+  const development = new URL('../../../view-renderer/src/index.js', import.meta.url);
+  if (existsSync(fileURLToPath(development))) return import(development.href);
+  throw usageError('The shared view renderer is missing. Rebuild or reinstall this CLI package.');
+}
+
+/** Root command registration supplies flags/output formatting; this adapter holds no browser JWT. */
+export async function renderViewWithCliRuntime({ runtime, url, outputs = ['markdown', 'screenshot'], width = 1440,
+  directory, signal, loadLibrary = rendererLibrary, request = httpRequest }) {
+  if (typeof url !== 'string' || !url.trim() || ![390, 1440].includes(width)) throw usageError('Choose a view link and width 390 or 1440.');
+  const ticket = (await request({ runtime, method: 'POST', path: '/portal_view_render/prepare', spacesProtocol: 1,
+    body: { url, outputs, width }, signal })).payload;
+  if (typeof ticket?.credential !== 'string') throw usageError('The short-lived render ticket is missing.');
+  const library = await loadLibrary();
+  const broker = library.createRemoteRenderBroker({ apiBase: runtime.apiBase, credential: ticket.credential });
+  let result;
+  try {
+    result = await library.renderView({ broker, outputs, width, signal });
+    await broker.complete(result, { signal });
+  }
+  catch (error) {
+    if (error instanceof library.ViewRenderError) throw new CliError({ code: error.code,
+      message: error.message, exitCode: EXIT_CODES.backend, retryable: error.status >= 500 || error.status === 429, cause: error });
+    throw error;
+  }
+  if (!directory) return { result, artifacts: null };
+  const root = resolve(directory), created = [], artifacts = {};
+  await mkdir(root, { recursive: true });
+  try {
+    for (const [kind, name, bytes] of [
+      ['markdown', 'view.md', result.markdown === undefined ? undefined : Buffer.from(result.markdown, 'utf8')],
+      ['screenshot', 'view.png', result.screenshot ? Buffer.from(result.screenshot.data_base64, 'base64') : undefined],
+    ]) {
+      if (bytes === undefined) continue;
+      const path = join(root, name);
+      await writeFile(path, bytes, { flag: 'wx', mode: 0o600 }); created.push(path); artifacts[kind] = path;
+    }
+  } catch (error) { await Promise.allSettled(created.map(path => unlink(path))); throw error; }
+  return { result, artifacts };
+}

package/src/skill-sync-worker-entry.js

@@ -0,0 +1,2 @@
+import { main } from './skill-sync-worker.js';
+await main();

package/src/skill-sync-worker.js

@@ -0,0 +1,50 @@
+import { mkdirSync, renameSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { resolveRuntimeProfile } from './runtime/profiles.js';
+import { ensureFreshOAuthCredential } from './runtime/oauth.js';
+import { runSkillSync, fetchSyncSettings } from '../dist/skill-sync/index.js';
+import { withSkillSyncLock } from './runtime/sync-skills.js';
+
+export async function runAutomaticSkillSync({ profile, apiBase, userId }, {
+  resolveRuntime = resolveRuntimeProfile, refresh = ensureFreshOAuthCredential,
+  settings = fetchSyncSettings, sync = runSkillSync, lock = withSkillSyncLock,
+} = {}) {
+  const runtime = resolveRuntime({ profile }, { requireAuth: true });
+  if (runtime.credentialKind !== 'oauth' || runtime.apiBase !== apiBase
+    || runtime.oauthUserId !== userId) throw new Error('Automatic skill sync account changed; run notis skills sync to rebind');
+  await refresh(runtime);
+  const saved = await settings(runtime.apiBase, runtime.jwt);
+  if (saved.user_id !== userId) throw new Error('Automatic skill sync identity mismatch');
+  // Do not gather, unlink foreign accounts or write anything when opted out.
+  if (!saved.sync_enabled) return { status: 'disabled' };
+  const result = await lock(() => sync(runtime.apiBase, runtime.jwt, {
+    fetchSyncSettings: async () => saved,
+  }, { honorSyncEnabled: true }));
+  return { status: (result.failedLinks?.length || result.failedPushes?.length) ? 'partial' : 'synced', ...result };
+}
+
+export async function main(args = process.argv.slice(2)) {
+  const [profile, apiBase, userId] = args;
+  const root = join(homedir(), '.notis', 'skills', 'service');
+  const record = (value) => {
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    const target = join(root, 'status.json');
+    const temporary = `${target}.${process.pid}.tmp`;
+    writeFileSync(temporary, JSON.stringify({ ...value, profile, at: new Date().toISOString() }, null, 2), { mode: 0o600 });
+    renameSync(temporary, target);
+  };
+  const deadline = setTimeout(() => {
+    record({ status: 'error', code: 'sync_timeout' });
+    process.exit(1);
+  }, 240_000);
+  try {
+    record(await runAutomaticSkillSync({ profile, apiBase, userId }));
+  } catch (error) {
+    // Persist only a classified error, never a bearer, signed URL or response body.
+    record({ status: 'error', code: error.code || 'sync_failed' });
+    process.exitCode = 1;
+  } finally {
+    clearTimeout(deadline);
+  }
+}

package/src/space-harness-host.ts

@@ -0,0 +1,103 @@
+import React from 'react';
+import * as ReactDOM from 'react-dom';
+import * as ReactDOMClient from 'react-dom/client';
+import * as JSXRuntime from 'react/jsx-runtime';
+import { importBundleSource, resolveBundleRouteExport } from '../../sdk/src/bundleModule';
+import { SdkPresentation } from '../../sdk/src/presentation';
+import { createPrefetchQueue, createQueryClient } from '../../sdk/src/queryCache';
+import type { NotisRuntime } from '../../sdk/src/runtime';
+import { SPACE_VIEWER_READ_OPERATIONS } from '../../sdk/src/space';
+import type { SpaceActionOptions, SpaceDocumentBodyRequest, SpaceViewerReadOperation } from '../../sdk/src/space';
+
+type Call = { op: string; actionId?: string; ok: boolean | null; error?: string };
+const state = { mounted: false, renderStarted: false, errors: [] as Array<{ phase: string; message: string }>, runtimeCalls: [] as Call[] };
+Object.assign(window, { __harness: state, React, ReactDOM, ReactDOMClient, __ReactJSXRuntime: JSXRuntime });
+const diagnostic = (phase: string, reason: unknown) => state.errors.push({ phase,
+  message: reason instanceof Error ? reason.message : String(reason || 'Verification failed.') });
+window.addEventListener('error', event => diagnostic('window_error', event.error || event.message));
+window.addEventListener('unhandledrejection', event => diagnostic('unhandled_rejection', event.reason));
+window.addEventListener('securitypolicyviolation', event => diagnostic('security_policy', `Blocked ${event.violatedDirective}`));
+
+async function start() {
+  const response = await fetch('/snapshot', { credentials: 'omit' });
+  if (!response.ok) throw new Error('The frozen verification snapshot could not be loaded.');
+  const snapshot = await response.json();
+  const authority = structuredClone(snapshot.descriptor.space);
+  const runFixture = async (call: Call, input: unknown) => {
+    state.runtimeCalls.push(call);
+    try {
+      const result = await fetch('/fixture', { method: 'POST', credentials: 'omit',
+        headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(input), signal: AbortSignal.timeout(5_000) });
+      const payload = await result.json();
+      if (!result.ok) throw new Error(payload.message || 'No matching synthetic fixture.');
+      call.ok = true; return payload.result;
+    } catch (error) {
+      call.ok = false; call.error = error instanceof Error ? error.message : 'Verification request failed.';
+      throw error;
+    }
+  };
+  const protocolFailure = (message: string): Promise<never> => { diagnostic('protocol', message); return Promise.reject(new Error(message)); };
+  const deny = () => protocolFailure('Use a declared Space action.');
+  const queue = createPrefetchQueue(2);
+  const runtime: NotisRuntime = {
+    ...snapshot.descriptor, databases: [],
+    context: { ...snapshot.descriptor.context,
+      resourceId: snapshot.descriptor.context?.resource_id ?? snapshot.descriptor.context?.resourceId ?? null,
+      collectionItem: snapshot.descriptor.context?.collection_item ?? snapshot.descriptor.context?.collectionItem ?? null },
+    queryClient: createQueryClient({ maxEntries: 100, schedule: queue }),
+    listTools: deny, callTool: deny, request: deny,
+    callAction<T>(id: string, inputs: Record<string, unknown> = {}, options: SpaceActionOptions = {}): Promise<T> {
+      if (!Object.hasOwn(authority.actions, id)) return protocolFailure('Undeclared verification action.');
+      if ((options.readOnly || options.dedupe) && authority.actions[id].readOnly !== true) {
+        return protocolFailure('A write action cannot run as a cached read.');
+      }
+      return runFixture({ op: 'callAction', actionId: id, ok: null }, { action_id: id, inputs });
+    },
+    viewerRead: authority.viewerReads?.length ? <T,>(operation: SpaceViewerReadOperation, input: Record<string, unknown> = {}): Promise<T> => {
+      const family = Object.hasOwn(SPACE_VIEWER_READ_OPERATIONS, operation) ? SPACE_VIEWER_READ_OPERATIONS[operation] : null;
+      if (!family || !authority.viewerReads.includes(family)) return protocolFailure('Undeclared verification viewer read.');
+      return runFixture({ op: 'viewerRead', actionId: operation, ok: null }, { viewer_read: { operation, input } });
+    } : undefined,
+    shown: Object.values(authority.shows || {}).some(list => 'database' in list) ? <T,>(name: string, params: Record<string, unknown> = {}): Promise<T> => {
+      const list = authority.shows && Object.hasOwn(authority.shows, name) ? authority.shows[name] : null;
+      if (!list || !('database' in list)) return protocolFailure('Undeclared verification list.');
+      return runFixture({ op: 'shown', actionId: name, ok: null }, { shown: { name, params } });
+    } : undefined,
+    documentBody(request: SpaceDocumentBodyRequest) {
+      return runFixture({ op: 'documentBody', actionId: request?.readAction, ok: null }, { document_body: request });
+    },
+    navigate(payload) {
+      if (payload.kind !== 'space-reference' || typeof payload.alias !== 'string' || !authority.navigation?.includes(payload.alias)) {
+        return protocolFailure('Offline navigation requires a declared synthetic destination.');
+      }
+      // This observes a declaration only; no live navigation or access is claimed.
+      state.runtimeCalls.push({ op: 'navigate', actionId: payload.alias, ok: true });
+    },
+    publishActiveResource() {}, captureContextSelection() {},
+    addContext: async () => false, updateContext: async () => false, removeContext: async () => false,
+    registerTopBarSearch() {}, setTopBarSearchValue() {}, setTopBarSearchLoading() {},
+  };
+  const module = await importBundleSource(snapshot.source);
+  const view = resolveBundleRouteExport(module, ['SpaceView'], true);
+  if (!view) throw new Error('The SpaceView export is missing from this presentation.');
+  const host = document.createElement('div'); host.style.cssText = 'min-height:100vh;height:100vh';
+  const shadow = host.attachShadow({ mode: 'open' });
+  const css = document.createElement('style'); css.textContent = snapshot.css; shadow.appendChild(css);
+  const mount = document.createElement('div'); mount.setAttribute('data-notis-app-mount', 'true');
+  mount.style.cssText = 'min-height:0;height:100%'; shadow.appendChild(mount);
+  document.body.appendChild(host);
+  const controller = document.createElement('div'); document.body.appendChild(controller);
+  const mode = new URLSearchParams(location.search).get('theme') === 'dark' ? 'dark' : 'light';
+  document.documentElement.classList.toggle('dark', mode === 'dark');
+  state.renderStarted = true;
+  ReactDOMClient.createRoot(controller).render(React.createElement(SdkPresentation, {
+    mount, runtime, component: view.component, shell: module.__AppShell, theme: { mode, style: { colorScheme: mode } },
+    resetKey: snapshot.cacheKey,
+    onCommit: (hasContent: boolean) => { state.mounted = hasContent; },
+    onError: (error: Error) => { state.mounted = false; state.errors.push({ phase: 'render', message: error.message }); },
+    onProtocolError: (error: Error) => diagnostic('protocol', error),
+    fallback: (error: Error) => React.createElement('div', { role: 'alert' }, error.message),
+  }));
+}
+
+void start().catch(reason => state.errors.push({ phase: 'boot', message: reason instanceof Error ? reason.message : 'Verification did not start.' }));