@happyvertical/smrt-template-sveltekit 0.43.9 → 0.44.0

package/template/src/lib/runtime-diagnostics-webmcp.ts

@@ -0,0 +1,108 @@
+export const RUNTIME_DIAGNOSTICS_WEBMCP_TOOL_NAME =
+  'smrt.runtime.diagnostics.read';
+
+interface RuntimeDiagnosticsTool {
+  readonly name: string;
+  readonly description: string;
+  readonly inputSchema: Record<string, unknown>;
+  readonly annotations: {
+    readonly readOnlyHint: true;
+    readonly destructiveHint: false;
+    readonly idempotentHint: true;
+    readonly openWorldHint: false;
+  };
+  readonly execute: (args: Record<string, unknown>) => Promise<string>;
+}
+
+interface RuntimeDiagnosticsModelContext {
+  registerTool(
+    tool: RuntimeDiagnosticsTool,
+    options: { signal: AbortSignal },
+  ): void | Promise<void>;
+}
+
+export interface RuntimeDiagnosticsWebMcpOwner {
+  readonly dispose: () => void;
+}
+
+export interface RegisterRuntimeDiagnosticsWebMcpOptions {
+  readonly fetchFn?: typeof fetch;
+  readonly modelContext?: RuntimeDiagnosticsModelContext;
+}
+
+/** Register exactly one page-user, read-only diagnostics tool for its owner. */
+export function registerRuntimeDiagnosticsWebMcp(
+  options: RegisterRuntimeDiagnosticsWebMcpOptions = {},
+): RuntimeDiagnosticsWebMcpOwner | null {
+  const modelContext =
+    options.modelContext ??
+    (globalThis as {
+      document?: { modelContext?: RuntimeDiagnosticsModelContext };
+    }).document?.modelContext;
+  if (!modelContext || typeof modelContext.registerTool !== 'function') {
+    return null;
+  }
+
+  const controller = new AbortController();
+  const tool = createRuntimeDiagnosticsWebMcpTool(options.fetchFn ?? fetch);
+  try {
+    const registration = modelContext.registerTool(tool, {
+      signal: controller.signal,
+    });
+    void Promise.resolve(registration).catch(() => controller.abort());
+  } catch {
+    controller.abort();
+  }
+  return Object.freeze({ dispose: () => controller.abort() });
+}
+
+export function createRuntimeDiagnosticsWebMcpTool(
+  fetchFn: typeof fetch,
+): RuntimeDiagnosticsTool {
+  return Object.freeze({
+    name: RUNTIME_DIAGNOSTICS_WEBMCP_TOOL_NAME,
+    description:
+      'Read the authenticated, redacted application runtime diagnostics.',
+    inputSchema: Object.freeze({
+      type: 'object',
+      properties: Object.freeze({}),
+      additionalProperties: false,
+    }),
+    annotations: Object.freeze({
+      readOnlyHint: true as const,
+      destructiveHint: false as const,
+      idempotentHint: true as const,
+      openWorldHint: false as const,
+    }),
+    async execute() {
+      let response: Response;
+      try {
+        response = await fetchFn('/api/_runtime/diagnostics', {
+          method: 'GET',
+          credentials: 'same-origin',
+          headers: { accept: 'application/json' },
+        });
+      } catch {
+        return stableToolError('diagnostics_unavailable');
+      }
+      if (!response.ok) {
+        return stableToolError(
+          response.status === 401
+            ? 'authentication_required'
+            : response.status === 403
+              ? 'authorization_denied'
+              : 'diagnostics_unavailable',
+        );
+      }
+      try {
+        return JSON.stringify(await response.json());
+      } catch {
+        return stableToolError('diagnostics_unavailable');
+      }
+    },
+  });
+}
+
+function stableToolError(code: string): string {
+  return JSON.stringify({ ok: false, error: { code } });
+}

package/template/src/lib/server/application-runtime.ts

@@ -0,0 +1,262 @@
+import {
+  initializeDeployedApplicationRuntime,
+  initializeLocalApplicationRuntime,
+  projectRuntimeDiagnostics,
+  resolveLocalRuntimePaths,
+  type LocalApplicationRuntime,
+  type RuntimeDiagnostics,
+  type RuntimeDiagnosticsProjectionInput,
+} from '@happyvertical/smrt-app-runtime';
+import {
+  loadConfig,
+  resolveApplicationRuntime,
+  resolveConfiguredApplicationRuntime,
+} from '@happyvertical/smrt-config';
+import type { SmrtClassOptions } from '@happyvertical/smrt-core';
+import { getDatabase } from '@happyvertical/sql';
+import {
+  prepareApplicationStateRoot,
+  resolveApplicationId,
+  runtimeConfigurationFingerprint,
+} from '../../../scripts/smrt-runtime-identity.mjs';
+import { acquireWriterLease } from '../../../scripts/smrt-writer-lease.mjs';
+import { createProviderReadinessProbe } from '../../../scripts/smrt-provider-readiness.mjs';
+
+const loadedConfig = await loadConfig();
+
+export const applicationRuntime = loadedConfig.runtime
+  ? resolveConfiguredApplicationRuntime()
+  : resolveApplicationRuntime({ profile: 'local' });
+const appId = resolveApplicationId({
+  sourceRoot: process.cwd(),
+  explicitId: process.env.SMRT_APP_ID,
+});
+
+export const applicationRuntimeConfiguration = runtimeConfigurationFingerprint(
+  applicationRuntime,
+  process.env,
+);
+
+export function getApplicationDatabaseConfig(): SmrtClassOptions['db'] {
+  if (applicationRuntime.profile === 'local') {
+    const paths = resolveLocalRuntimePaths({
+      appId,
+      dataDirectory: process.env.SMRT_DATA_DIR,
+      sourceRoot: process.cwd(),
+    });
+    return { type: 'sqlite', url: paths.database };
+  }
+  const databaseUrl = process.env.DATABASE_URL;
+  if (!databaseUrl) {
+    throw new Error(`${applicationRuntime.profile} requires DATABASE_URL.`);
+  }
+  return { type: 'postgres', url: databaseUrl };
+}
+
+let localRuntimePromise: Promise<LocalApplicationRuntime> | undefined;
+let localWriterLease: { release(): void } | undefined;
+let deployedRuntimePromise: ReturnType<
+  typeof initializeDeployedApplicationRuntime
+> | undefined;
+
+/** Fail-closed startup gate for every deployed web process. */
+export async function ensureApplicationRuntimeReady(): Promise<void> {
+  if (applicationRuntime.profile === 'local') {
+    await getLocalApplicationRuntime();
+    return;
+  }
+  const databaseUrl = process.env.DATABASE_URL;
+  if (!databaseUrl) {
+    throw new Error(`${applicationRuntime.profile} requires DATABASE_URL.`);
+  }
+  const authenticationProvider =
+    applicationRuntime.providers.authentication.provider;
+  if (authenticationProvider === 'owner-bootstrap') {
+    throw new Error('Deployed profiles require public authentication.');
+  }
+  deployedRuntimePromise ??= initializeDeployedApplicationRuntime({
+    profile: applicationRuntime.profile,
+    providers: {
+      database: applicationRuntime.providers.database,
+      authentication: applicationRuntime.providers.authentication,
+      tenancy: applicationRuntime.providers.tenancy,
+      assets: applicationRuntime.providers.assets,
+      secrets: applicationRuntime.providers.secrets,
+      jobs: applicationRuntime.providers.jobs,
+      network: applicationRuntime.providers.network,
+    },
+    database: {
+      engine: 'postgres',
+      connect: () => getDatabase({ type: 'postgres', url: databaseUrl }),
+      close: async (db) => db.close?.(),
+    },
+    authentication: {
+      provider: authenticationProvider,
+      readiness: createProviderReadinessProbe('authentication', {
+        profile: applicationRuntime.profile,
+        provider: authenticationProvider,
+      }),
+    },
+    assets: {
+      provider: applicationRuntime.providers.assets.provider,
+      readiness: createProviderReadinessProbe('assets', {
+        profile: applicationRuntime.profile,
+        provider: applicationRuntime.providers.assets.provider,
+      }),
+    },
+    secrets: {
+      provider: applicationRuntime.providers.secrets.provider,
+      readiness: createProviderReadinessProbe('secrets', {
+        profile: applicationRuntime.profile,
+        provider: applicationRuntime.providers.secrets.provider,
+      }),
+    },
+  });
+  await deployedRuntimePromise;
+}
+
+/** Local onboarding runtime. Deployed authentication belongs to its provider. */
+export function getLocalApplicationRuntime(): Promise<LocalApplicationRuntime> {
+  if (applicationRuntime.profile !== 'local') {
+    throw new Error('Owner bootstrap is available only in the local profile.');
+  }
+  const bindHost =
+    process.env.HOST ||
+    (process.env.NODE_ENV === 'development' ? '127.0.0.1' : null);
+  if (!bindHost) {
+    throw new Error(
+      'Local production startup requires an explicit loopback HOST; use pnpm app:start.',
+    );
+  }
+  localWriterLease ??= acquireWriterLease(
+    prepareApplicationStateRoot({
+      appId,
+      dataDirectory: process.env.SMRT_DATA_DIR,
+      sourceRoot: process.cwd(),
+    }),
+    { operationInstance: process.env.SMRT_OPERATION_INSTANCE },
+  );
+  localRuntimePromise ??= initializeLocalApplicationRuntime({
+    appId,
+    dataDirectory: process.env.SMRT_DATA_DIR,
+    sourceRoot: process.cwd(),
+    bindHost,
+    providers: {
+      database: applicationRuntime.providers.database,
+      authentication: applicationRuntime.providers.authentication,
+      tenancy: applicationRuntime.providers.tenancy,
+      assets: applicationRuntime.providers.assets,
+      secrets: applicationRuntime.providers.secrets,
+      jobs: applicationRuntime.providers.jobs,
+      network: applicationRuntime.providers.network,
+    },
+    backgroundJobs: process.env.SMRT_BACKGROUND_JOBS === 'true',
+  })
+    .then(({ runtime }) => runtime)
+    .catch((error) => {
+      localWriterLease?.release();
+      localWriterLease = undefined;
+      localRuntimePromise = undefined;
+      throw error;
+    });
+  return localRuntimePromise;
+}
+
+export interface ApplicationRuntimeDiagnosticsOptions {
+  readonly toolNames: readonly string[];
+  readonly observedAt: Date;
+  /** Application-owned schema verification seam; runtime liveness is not proof. */
+  readonly schemaStatus?: 'not-ready' | 'ready' | 'unknown';
+  /** Application-owned migration tracker seam; database liveness is not proof. */
+  readonly migrationStatus?: 'current' | 'failed' | 'pending' | 'unknown';
+  /** Bounded worker seam supplied by the deployment's lease/heartbeat adapter. */
+  readonly workerHeartbeatAt?: Date | string | null;
+  /** Stable code/timestamp pairs only; raw errors never cross this seam. */
+  readonly recentErrors?: readonly {
+    readonly code?: unknown;
+    readonly at?: unknown;
+  }[];
+}
+
+/**
+ * Read the private runtime only after the route has authenticated and
+ * authorized its caller, then immediately project onto the public allowlist.
+ */
+export async function readApplicationRuntimeDiagnostics(
+  options: ApplicationRuntimeDiagnosticsOptions,
+): Promise<RuntimeDiagnostics> {
+  await ensureApplicationRuntimeReady();
+
+  if (applicationRuntime.profile === 'local') {
+    const runtime = await getLocalApplicationRuntime();
+    const diagnostics = await runtime.diagnostics();
+    return projectRuntimeDiagnostics({
+      profile: 'local',
+      health: 'healthy',
+      schema: {
+        status: options.schemaStatus ?? 'unknown',
+        migrations: options.migrationStatus ?? 'unknown',
+      },
+      capabilities: {
+        'asset-storage': 'available',
+        authentication: 'available',
+        'background-jobs': diagnostics.jobs.backgroundEnabled
+          ? 'available'
+          : 'disabled',
+        database: 'available',
+        'paid-capabilities': diagnostics.paidCapabilitiesEnabled
+          ? 'available'
+          : 'disabled',
+        'secret-storage': 'available',
+      },
+      toolNames: options.toolNames,
+      worker: {
+        topology: diagnostics.jobs.topology,
+        required: diagnostics.jobs.backgroundEnabled,
+        heartbeatAt: options.workerHeartbeatAt,
+      },
+      recentErrors: options.recentErrors,
+      observedAt: options.observedAt,
+    });
+  }
+
+  const runtime = await deployedRuntimePromise;
+  if (!runtime) throw new Error('deployed_runtime_unavailable');
+  const readiness = await runtime.readiness();
+  const componentStatus = (
+    component: keyof typeof readiness.components,
+  ): 'available' | 'unavailable' =>
+    readiness.components[component].status === 'ready'
+      ? 'available'
+      : 'unavailable';
+  const input: RuntimeDiagnosticsProjectionInput = {
+    profile: applicationRuntime.profile,
+    health:
+      runtime.health().status === 'healthy'
+        ? readiness.status === 'ready'
+          ? 'healthy'
+          : 'degraded'
+        : 'stopped',
+    schema: {
+      status: options.schemaStatus ?? 'unknown',
+      migrations: options.migrationStatus ?? 'unknown',
+    },
+    capabilities: {
+      'asset-storage': componentStatus('assets'),
+      authentication: componentStatus('authentication'),
+      'background-jobs': 'available',
+      database: componentStatus('database'),
+      'paid-capabilities': 'unknown',
+      'secret-storage': componentStatus('secrets'),
+    },
+    toolNames: options.toolNames,
+    worker: {
+      topology: runtime.resolvedRuntime.providers.jobs.topology,
+      required: true,
+      heartbeatAt: options.workerHeartbeatAt,
+    },
+    recentErrors: options.recentErrors,
+    observedAt: options.observedAt,
+  };
+  return projectRuntimeDiagnostics(input);
+}

package/template/src/lib/server/runtime-diagnostics.ts

@@ -0,0 +1,114 @@
+import type { RuntimeDiagnostics } from '@happyvertical/smrt-app-runtime';
+import type { Role } from '@happyvertical/smrt-users';
+import { webMcpToolDefinitions } from '@happyvertical/smrt-virt-web';
+import { json } from '@sveltejs/kit';
+
+import { getCollection } from './smrt.js';
+import { readApplicationRuntimeDiagnostics } from './application-runtime.js';
+import { RUNTIME_DIAGNOSTICS_WEBMCP_TOOL_NAME } from '../runtime-diagnostics-webmcp.js';
+
+export const RUNTIME_DIAGNOSTICS_READ_PERMISSION = 'runtime_diagnostics.read';
+
+interface DiagnosticsLocals {
+  readonly user?: { readonly id?: unknown } | null;
+  readonly membership?: {
+    readonly userId?: unknown;
+    readonly tenantId?: unknown;
+    readonly roleId?: unknown;
+    isActive?: () => boolean;
+  } | null;
+  readonly permissions?: readonly string[];
+  readonly tenantId?: unknown;
+  readonly sessionId?: unknown;
+}
+
+interface RuntimeDiagnosticsHandlerOptions {
+  readonly resolveRoleSlug: (roleId: string) => Promise<string | null>;
+  readonly readDiagnostics: () => Promise<RuntimeDiagnostics>;
+}
+
+/** Testable route boundary: authorization always completes before projection. */
+export function createRuntimeDiagnosticsGet(
+  options: RuntimeDiagnosticsHandlerOptions,
+) {
+  return async ({ locals }: { locals: DiagnosticsLocals }) => {
+    const principal = authenticatedPrincipal(locals);
+    if (!principal) {
+      return stableError(401, 'authentication_required');
+    }
+
+    let authorized =
+      locals.permissions?.includes(RUNTIME_DIAGNOSTICS_READ_PERMISSION) === true;
+    if (!authorized) {
+      try {
+        authorized = (await options.resolveRoleSlug(principal.roleId)) === 'owner';
+      } catch {
+        authorized = false;
+      }
+    }
+    if (!authorized) return stableError(403, 'authorization_denied');
+
+    try {
+      return json(await options.readDiagnostics());
+    } catch {
+      return stableError(503, 'diagnostics_unavailable');
+    }
+  };
+}
+
+export const runtimeDiagnosticsGet = createRuntimeDiagnosticsGet({
+  async resolveRoleSlug(roleId) {
+    const roles = await getCollection<Role>('Role');
+    return (await roles.findById(roleId))?.slug ?? null;
+  },
+  readDiagnostics: () =>
+    readApplicationRuntimeDiagnostics({
+      toolNames: [
+        ...webMcpToolDefinitions.map((definition) => definition.name),
+        RUNTIME_DIAGNOSTICS_WEBMCP_TOOL_NAME,
+      ],
+      observedAt: new Date(),
+      // Install application migration/schema verifiers here. Process/database
+      // liveness alone intentionally leaves both values `unknown`.
+      schemaStatus: 'unknown',
+      migrationStatus: 'unknown',
+      // External deployments install their lease-backed heartbeat adapter here.
+      // Missing data remains `unknown`; web-process liveness is never substituted.
+      workerHeartbeatAt: null,
+      recentErrors: [],
+    }),
+});
+
+function authenticatedPrincipal(locals: DiagnosticsLocals): {
+  roleId: string;
+} | null {
+  const userId = locals.user?.id;
+  const tenantId = locals.tenantId;
+  const sessionId = locals.sessionId;
+  const membership = locals.membership;
+  if (
+    typeof userId !== 'string' ||
+    !userId ||
+    typeof tenantId !== 'string' ||
+    !tenantId ||
+    typeof sessionId !== 'string' ||
+    !sessionId ||
+    !membership ||
+    membership.userId !== userId ||
+    membership.tenantId !== tenantId ||
+    typeof membership.roleId !== 'string' ||
+    !membership.roleId
+  ) {
+    return null;
+  }
+  try {
+    if (membership.isActive?.() !== true) return null;
+  } catch {
+    return null;
+  }
+  return { roleId: membership.roleId };
+}
+
+function stableError(status: number, code: string) {
+  return json({ schemaVersion: 1, error: { code } }, { status });
+}

package/template/src/lib/server/smrt.ts

@@ -16,6 +16,8 @@ import {
 import { loadManifestFromPathSync } from '@happyvertical/smrt-core/manifest';
 import { getRequestScopedDatabase } from '@happyvertical/smrt-users';
 
+import { getApplicationDatabaseConfig } from './application-runtime.js';
+
 // Import all SMRT objects to register them.
 import '../objects/index.js';
 
@@ -25,6 +27,7 @@ import '../objects/index.js';
 // (it is gitignored, like the generated API routes); guard the import so a
 // fresh checkout that has not run the plugin yet still boots.
 try {
+  // @ts-ignore generated by smrtPlugin before a consumer build starts
   await import('./smrt-register.js');
 } catch (error) {
   // Not generated yet — the first `vite dev` / `vite build` creates it. Do
@@ -66,10 +69,7 @@ const objectOverrides: Record<string, Partial<SmrtClassOptions>> = {
  */
 function getDefaultConfig(): SmrtClassOptions {
   return {
-    db: {
-      url: process.env.DATABASE_URL || './app.db',
-      type: (process.env.DATABASE_TYPE as 'sqlite' | 'postgres') || 'sqlite',
-    },
+    db: getApplicationDatabaseConfig(),
   };
 }
 

package/template/src/routes/+layout.svelte

@@ -10,6 +10,7 @@
   } from '@happyvertical/smrt-svelte/workspace';
   import { ThemeProvider } from '@happyvertical/smrt-ui/themes';
   import '@happyvertical/smrt-ui/themes/styles/fonts.css';
+  import RuntimeDiagnosticsWebMcp from '$lib/RuntimeDiagnosticsWebMcp.svelte';
   import type { LayoutProps } from './$types';
 
   let { data, children }: LayoutProps = $props();
@@ -48,6 +49,7 @@
 </script>
 
 <Provider {webmcp}>
+  <RuntimeDiagnosticsWebMcp enabled={data.session.authenticated} />
   <ThemeProvider preset="smrt" colorScheme="system" persist={true}>
     <AdminShell
       title="s-m-r-t app"

package/template/src/routes/api/_runtime/diagnostics/+server.ts

@@ -0,0 +1,5 @@
+import type { RequestHandler } from './$types';
+
+import { runtimeDiagnosticsGet } from '$lib/server/runtime-diagnostics';
+
+export const GET: RequestHandler = runtimeDiagnosticsGet;

package/template/src/routes/api/_runtime/health/+server.ts

@@ -0,0 +1,30 @@
+import { json } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { resolveApplicationId } from '../../../../../scripts/smrt-runtime-identity.mjs';
+import {
+  applicationRuntime,
+  applicationRuntimeConfiguration,
+} from '$lib/server/application-runtime';
+
+const applicationId = resolveApplicationId({
+  sourceRoot: process.cwd(),
+  explicitId: process.env.SMRT_APP_ID,
+});
+
+export const GET: RequestHandler = async () => {
+  const publicHealth = {
+    schemaVersion: 1,
+    status: 'ready',
+    profile: applicationRuntime.profile,
+  };
+  return json(
+    applicationRuntime.profile === 'local'
+      ? {
+          ...publicHealth,
+          application: applicationId,
+          instance: process.env.SMRT_PROCESS_INSTANCE || null,
+          configuration: applicationRuntimeConfiguration,
+        }
+      : publicHealth,
+  );
+};

package/template/src/routes/setup/+page.server.ts

@@ -0,0 +1,96 @@
+import { rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { fail, redirect } from '@sveltejs/kit';
+import type { Actions, PageServerLoad } from './$types';
+
+import {
+  applicationRuntime,
+  getLocalApplicationRuntime,
+} from '$lib/server/application-runtime';
+import {
+  resolveApplicationId,
+  resolveApplicationStateRoot,
+} from '../../../scripts/smrt-runtime-identity.mjs';
+
+export const load: PageServerLoad = async ({ url, locals }) => {
+  if (locals.user) throw redirect(303, '/');
+  if (applicationRuntime.profile !== 'local') {
+    return { available: false, token: '' };
+  }
+  const runtime = await getLocalApplicationRuntime();
+  const diagnostics = await runtime.diagnostics();
+  return {
+    available: diagnostics.bootstrap.status !== 'claimed',
+    token: url.searchParams.get('token') || '',
+  };
+};
+
+export const actions: Actions = {
+  default: async (event) => {
+    if (applicationRuntime.profile !== 'local') {
+      return fail(404, { message: 'Local owner setup is disabled.' });
+    }
+    const form = await event.request.formData();
+    const token = String(form.get('token') || '');
+    const name = String(form.get('name') || '');
+    const email = String(form.get('email') || '');
+    if (!token || !name.trim() || !email.includes('@')) {
+      return fail(400, { message: 'Name, email, and a valid setup token are required.' });
+    }
+    const runtime = await getLocalApplicationRuntime();
+    let result;
+    try {
+      result = await runtime.claimOwner({
+        token,
+        name,
+        email,
+        userAgent: event.request.headers.get('user-agent') || undefined,
+        ipAddress: event.getClientAddress(),
+      });
+    } catch {
+      return fail(400, {
+        message:
+          'The setup invitation is invalid, expired, or already used. Run pnpm app:stop, pnpm app:recover, pnpm app:start, then pnpm app:open.',
+      });
+    }
+    event.cookies.set('sid', result.sessionId, {
+      path: '/',
+      httpOnly: true,
+      secure: event.url.protocol === 'https:',
+      sameSite: 'lax',
+      maxAge: 7 * 24 * 60 * 60,
+    });
+    try {
+      const appId = resolveApplicationId({
+        sourceRoot: process.cwd(),
+        explicitId: process.env.SMRT_APP_ID,
+      });
+      rmSync(
+        join(
+          resolveApplicationStateRoot({
+            appId,
+            dataDirectory: process.env.SMRT_DATA_DIR,
+            sourceRoot: process.cwd(),
+          }),
+          'onboarding.json',
+        ),
+        { force: true },
+      );
+      rmSync(
+        join(
+          resolveApplicationStateRoot({
+            appId,
+            dataDirectory: process.env.SMRT_DATA_DIR,
+            sourceRoot: process.cwd(),
+          }),
+          'onboarding-launch.html',
+        ),
+        { force: true },
+      );
+    } catch {
+      // The owner and session are authoritative; stale mode-0600 handoff files
+      // only contain a token that now fails closed as already claimed.
+    }
+    throw redirect(303, '/');
+  },
+};

package/template/src/routes/setup/+page.svelte

@@ -0,0 +1,31 @@
+<script lang="ts">
+  import type { PageProps } from './$types';
+
+  let { data, form }: PageProps = $props();
+</script>
+
+<svelte:head><title>Set up your local application</title></svelte:head>
+
+<main>
+  <h1>Set up your local application</h1>
+  {#if !data.available}
+    <p>Local owner setup is unavailable or has already been completed.</p>
+  {:else}
+    <p>Create the real local owner account. This invitation works once and stays on this device.</p>
+    {#if form?.message}<p role="alert">{form.message}</p>{/if}
+    <form method="POST">
+      <input type="hidden" name="token" value={data.token} />
+      <label>Name <input name="name" autocomplete="name" required /></label>
+      <label>Email <input name="email" type="email" autocomplete="email" required /></label>
+      <button type="submit">Create owner</button>
+    </form>
+  {/if}
+</main>
+
+<style>
+  main { max-width: 36rem; margin: 4rem auto; padding: 1.5rem; }
+  form { display: grid; gap: 1rem; }
+  label { display: grid; gap: 0.35rem; }
+  input { padding: 0.65rem; }
+  button { width: fit-content; padding: 0.65rem 1rem; }
+</style>