@trypattern/sdk 0.1.0 → 0.1.2

package/dist/flows/flows.js

@@ -2,6 +2,7 @@ import { createMemoryRouter } from 'react-router';
 import { afterAll, expect, inject, test } from 'vitest';
 import { apiCalls, memoryApi } from "../api.js";
 import { Cache } from "../cache.js";
+import { manualClock } from "../clock.js";
 import { Gate } from "../gate.js";
 import { routeObjects } from "../routes.js";
 import { screenshotNameProblem } from "./screenshotName.js";
@@ -47,6 +48,12 @@ async function runSteps(name, steps, run) {
         else if ('restart' in step) {
             await run.restart();
         }
+        else if ('tick' in step) {
+            await run.tick();
+        }
+        else if ('world' in step) {
+            await run.world(step.world);
+        }
         else {
             expect(await run.snapshot(), `step ${index + 1} of "${name}": expected ${JSON.stringify(step.expect)}`).toMatchObject(step.expect);
         }
@@ -61,18 +68,30 @@ function withTestParams(path, failing, held) {
     return `${path}?${params.toString()}`;
 }
 export function defineFlow({ App }) {
-    const { tables, routes } = App.definition;
+    const { tables, routes, services, memory } = App.definition;
     const seed = (inject('patternSeed') ?? {});
     const admins = inject('patternAdmins') ?? [];
-    const calls = apiCalls(tables);
+    const title = inject('patternTitle') ?? '';
+    const startingWorld = inject('patternWorld') ?? {};
+    const calls = apiCalls(tables, services);
     const router = (path) => createMemoryRouter(routeObjects(routes), { initialEntries: [path] });
     function headless(name, steps, startAt, failing, signedInAs) {
         test(name, async () => {
             const gate = new Gate(failing);
+            const world = structuredClone(startingWorld);
             const deps = {
-                api: memoryApi(tables, seed, { gate, signedInAs, admins }),
+                api: memoryApi(tables, seed, {
+                    gate,
+                    signedInAs,
+                    admins,
+                    title,
+                    world,
+                    ...(services === undefined ? {} : { services }),
+                    ...(memory === undefined ? {} : { memory })
+                }),
                 cache: Cache.memory(),
-                gate
+                gate,
+                clock: manualClock()
             };
             let app = new App(router(startAt), deps);
             await runSteps(name, steps, {
@@ -86,6 +105,12 @@ export function defineFlow({ App }) {
                 release: async (call) => gate.release(call),
                 restart: async () => {
                     app = new App(router(app.getSnapshot().path), deps);
+                },
+                tick: async () => {
+                    app.tick();
+                },
+                world: async (patch) => {
+                    Object.assign(Object(world), patch);
                 }
             });
             await app.whenIdle();
@@ -109,7 +134,7 @@ export function defineFlow({ App }) {
             test(`${name} [${viewport}]`, async () => {
                 const { openFlowPage } = await import("./flowBrowser.js");
                 const held = new Set();
-                const page = await openFlowPage(visual, viewport, withTestParams(startAt, failing, held), signedInAs, seed, admins);
+                const page = await openFlowPage(visual, viewport, withTestParams(startAt, failing, held), signedInAs, seed, admins, startingWorld);
                 let stepFailure;
                 try {
                     await runSteps(name, steps, {
@@ -124,6 +149,8 @@ export function defineFlow({ App }) {
                             held.delete(call);
                             await page.release(call);
                         },
+                        tick: page.tick,
+                        world: page.world,
                         restart: async () => {
                             const snapshot = await page.snapshot();
                             const path = typeof snapshot === 'object' && snapshot !== null

package/dist/hooks/appContext.d.ts

@@ -1,11 +1,12 @@
 import type { Toasts } from '../builtins/Toasts.ts';
+import type { AppStore } from '../appInfo.ts';
 import type { AppModels } from '../registered.ts';
 import type { AppProviderOf, UseModel } from './appHooks.ts';
 export type ReactApp = {
-    readonly name: string;
     readonly models: AppModels;
     readonly stores: {
         readonly toasts: Toasts;
+        readonly app: AppStore;
     };
     pressKey(key: string): Promise<void> | undefined;
 };

package/dist/index.d.ts

@@ -18,8 +18,12 @@ export { userSchema } from './auth/user.ts';
 export type { User } from './auth/user.ts';
 export type { AppClass, AppDefinition, AppDependencies, AppSnapshotShape, DataRouter, ModelServicesOf, NavigateCommand, PressKeyCommand, PublicStores, PlainJsonModel, RunningApp, StoreClasses, StoreInstances, StoresOf, TableStores } from './app.ts';
 export { defineRoutes } from './routes.ts';
+export { ServiceRefused, refused } from './services.ts';
+export type { ServiceClient, ServiceMemory } from './services.ts';
+export { manualClock, realClock } from './clock.ts';
+export type { Clock } from './clock.ts';
 export type { PageOf, PathOf, RouteDefinition } from './routes.ts';
-export { Model, action, appPath, defineActions } from './registered.ts';
+export { Model, Store, action, appPath, defineActions } from './registered.ts';
 export type { ActionContext, AppAction, AppActionGroup, AppCommand, AppModels, AppPage, AppPath, AppSnapshot, AppStores, ModelServices, Register } from './registered.ts';
 export { Cache, Cached } from './cache.ts';
 export type { CacheStorage } from './cache.ts';
@@ -28,7 +32,7 @@ export type { Entity, EntityApi, EntityCall, EntityDeps, EntitySnapshot, Pending
 export { Gate } from './gate.ts';
 export { MemoryEntityApi, MemoryServer } from './memoryApi.ts';
 export type { MemoryApiOptions } from './memoryApi.ts';
-export { Store, StoreBase, keepEqualParts, snapshotsOf } from './store.ts';
+export { StoreBase, keepEqualParts, snapshotsOf } from './store.ts';
 export type { Snapshots, StoreClass, StoreConfig } from './store.ts';
 export type { Json, Persisted, StateOf, StateSpec } from './state.ts';
 export { defineTables } from './table.ts';

package/dist/index.js

@@ -8,12 +8,14 @@ export { SessionStore } from "./auth/sessionStore.js";
 export { HttpSessionApi, MemorySessionApi } from "./auth/sessionApi.js";
 export { userSchema } from "./auth/user.js";
 export { defineRoutes } from "./routes.js";
-export { Model, action, appPath, defineActions } from "./registered.js";
+export { ServiceRefused, refused } from "./services.js";
+export { manualClock, realClock } from "./clock.js";
+export { Model, Store, action, appPath, defineActions } from "./registered.js";
 export { Cache, Cached } from "./cache.js";
 export { EntityStore, WriteRefused, entityCalls } from "./entityStore.js";
 export { Gate } from "./gate.js";
 export { MemoryEntityApi, MemoryServer } from "./memoryApi.js";
-export { Store, StoreBase, keepEqualParts, snapshotsOf } from "./store.js";
+export { StoreBase, keepEqualParts, snapshotsOf } from "./store.js";
 export { defineTables } from "./table.js";
 export { HttpTableApi, MemoryTableApi, PublicTableStore, TableStore, httpTables, memoryTables, publicStoreName, tableCalls } from "./tables.js";
 export { ModelBase, command, commandsOf, createModels, modelSnapshotsOf, parseMessage, sendMessage, splitType } from "./model.js";

package/dist/publishWire.d.ts

@@ -0,0 +1,271 @@
+import { z } from 'zod';
+import { appTitle } from './appTitle.ts';
+export { appTitle };
+export declare const DASHBOARD_URL = "https://onpattern.app";
+export declare const APPS_DOMAIN = "onpattern.app";
+export declare const UPLOAD_LIMIT_BYTES: number;
+export declare const UPLOAD_LIMIT_PARTS = 5000;
+export declare function nameProblem(name: string): string | undefined;
+export declare const appName: z.ZodString;
+export declare function hostnameOf(name: string): string;
+export declare function isPrivatePath(path: string): boolean;
+export declare function sourcePathProblem(path: string): string | undefined;
+export declare const UPLOAD: {
+    readonly worker: "worker/";
+    readonly client: "client/";
+    readonly migrations: "migrations/";
+    readonly source: "source/";
+    readonly compatibilityDate: "compatibilityDate";
+    readonly sdkVersion: "sdkVersion";
+};
+export declare const publishStep: z.ZodEnum<{
+    publish: "publish";
+    reserve: "reserve";
+    database: "database";
+    "sign-in": "sign-in";
+}>;
+export type PublishStep = z.output<typeof publishStep>;
+export declare const publishStatus: z.ZodEnum<{
+    failed: "failed";
+    running: "running";
+    live: "live";
+}>;
+export declare const publishSummary: z.ZodObject<{
+    number: z.ZodNumber;
+    status: z.ZodEnum<{
+        failed: "failed";
+        running: "running";
+        live: "live";
+    }>;
+    step: z.ZodEnum<{
+        publish: "publish";
+        reserve: "reserve";
+        database: "database";
+        "sign-in": "sign-in";
+    }>;
+    error: z.ZodNullable<z.ZodString>;
+    byEmail: z.ZodString;
+    restoredFrom: z.ZodNullable<z.ZodNumber>;
+    isStarter: z.ZodBoolean;
+    startedAt: z.ZodString;
+    finishedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type PublishSummary = z.output<typeof publishSummary>;
+export declare const appSummary: z.ZodObject<{
+    name: z.ZodString;
+    title: z.ZodString;
+    url: z.ZodString;
+    pulledAt: z.ZodNullable<z.ZodString>;
+    latest: z.ZodNullable<z.ZodObject<{
+        number: z.ZodNumber;
+        status: z.ZodEnum<{
+            failed: "failed";
+            running: "running";
+            live: "live";
+        }>;
+        step: z.ZodEnum<{
+            publish: "publish";
+            reserve: "reserve";
+            database: "database";
+            "sign-in": "sign-in";
+        }>;
+        error: z.ZodNullable<z.ZodString>;
+        byEmail: z.ZodString;
+        restoredFrom: z.ZodNullable<z.ZodNumber>;
+        isStarter: z.ZodBoolean;
+        startedAt: z.ZodString;
+        finishedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AppSummary = z.output<typeof appSummary>;
+export declare const nameSuggestion: z.ZodObject<{
+    name: z.ZodString;
+    available: z.ZodBoolean;
+    problem: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type NameSuggestion = z.output<typeof nameSuggestion>;
+export declare const loginStarted: z.ZodObject<{
+    secret: z.ZodString;
+    code: z.ZodString;
+    url: z.ZodString;
+}, z.core.$strip>;
+export declare const loginPoll: z.ZodUnion<readonly [z.ZodObject<{
+    status: z.ZodLiteral<"waiting">;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"approved">;
+    cookie: z.ZodString;
+}, z.core.$strip>]>;
+export declare const loginToApprove: z.ZodObject<{
+    code: z.ZodString;
+    label: z.ZodString;
+}, z.core.$strip>;
+export declare const publishServices: {
+    readonly apps: {
+        readonly list: NoInfer<import("./services.ts").ServiceCall<"/apps", {}, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            title: z.ZodString;
+            url: z.ZodString;
+            pulledAt: z.ZodNullable<z.ZodString>;
+            latest: z.ZodNullable<z.ZodObject<{
+                number: z.ZodNumber;
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    running: "running";
+                    live: "live";
+                }>;
+                step: z.ZodEnum<{
+                    publish: "publish";
+                    reserve: "reserve";
+                    database: "database";
+                    "sign-in": "sign-in";
+                }>;
+                error: z.ZodNullable<z.ZodString>;
+                byEmail: z.ZodString;
+                restoredFrom: z.ZodNullable<z.ZodNumber>;
+                isStarter: z.ZodBoolean;
+                startedAt: z.ZodString;
+                finishedAt: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>>;
+        readonly read: NoInfer<import("./services.ts").ServiceCall<"/apps/:name", {}, z.ZodObject<{
+            name: z.ZodString;
+            title: z.ZodString;
+            url: z.ZodString;
+            pulledAt: z.ZodNullable<z.ZodString>;
+            latest: z.ZodNullable<z.ZodObject<{
+                number: z.ZodNumber;
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    running: "running";
+                    live: "live";
+                }>;
+                step: z.ZodEnum<{
+                    publish: "publish";
+                    reserve: "reserve";
+                    database: "database";
+                    "sign-in": "sign-in";
+                }>;
+                error: z.ZodNullable<z.ZodString>;
+                byEmail: z.ZodString;
+                restoredFrom: z.ZodNullable<z.ZodNumber>;
+                isStarter: z.ZodBoolean;
+                startedAt: z.ZodString;
+                finishedAt: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        readonly create: NoInfer<import("./services.ts").ServiceCall<"/apps", {
+            name: z.ZodString;
+            title: z.ZodString;
+        }, z.ZodObject<{
+            name: z.ZodString;
+            title: z.ZodString;
+            url: z.ZodString;
+            pulledAt: z.ZodNullable<z.ZodString>;
+            latest: z.ZodNullable<z.ZodObject<{
+                number: z.ZodNumber;
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    running: "running";
+                    live: "live";
+                }>;
+                step: z.ZodEnum<{
+                    publish: "publish";
+                    reserve: "reserve";
+                    database: "database";
+                    "sign-in": "sign-in";
+                }>;
+                error: z.ZodNullable<z.ZodString>;
+                byEmail: z.ZodString;
+                restoredFrom: z.ZodNullable<z.ZodNumber>;
+                isStarter: z.ZodBoolean;
+                startedAt: z.ZodString;
+                finishedAt: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    };
+    readonly names: {
+        readonly suggest: NoInfer<import("./services.ts").ServiceCall<"/names", {
+            title: z.ZodString;
+        }, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            available: z.ZodBoolean;
+            problem: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>>;
+        readonly check: NoInfer<import("./services.ts").ServiceCall<"/names/:name", {}, z.ZodObject<{
+            name: z.ZodString;
+            available: z.ZodBoolean;
+            problem: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+    };
+    readonly publishes: {
+        readonly list: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/publishes", {}, z.ZodArray<z.ZodObject<{
+            number: z.ZodNumber;
+            status: z.ZodEnum<{
+                failed: "failed";
+                running: "running";
+                live: "live";
+            }>;
+            step: z.ZodEnum<{
+                publish: "publish";
+                reserve: "reserve";
+                database: "database";
+                "sign-in": "sign-in";
+            }>;
+            error: z.ZodNullable<z.ZodString>;
+            byEmail: z.ZodString;
+            restoredFrom: z.ZodNullable<z.ZodNumber>;
+            isStarter: z.ZodBoolean;
+            startedAt: z.ZodString;
+            finishedAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>>;
+        readonly read: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/publishes/:number", {}, z.ZodObject<{
+            number: z.ZodNumber;
+            status: z.ZodEnum<{
+                failed: "failed";
+                running: "running";
+                live: "live";
+            }>;
+            step: z.ZodEnum<{
+                publish: "publish";
+                reserve: "reserve";
+                database: "database";
+                "sign-in": "sign-in";
+            }>;
+            error: z.ZodNullable<z.ZodString>;
+            byEmail: z.ZodString;
+            restoredFrom: z.ZodNullable<z.ZodNumber>;
+            isStarter: z.ZodBoolean;
+            startedAt: z.ZodString;
+            finishedAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+        readonly retry: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/publishes/:number/retry", {}, z.ZodObject<{
+            number: z.ZodNumber;
+            status: z.ZodEnum<{
+                failed: "failed";
+                running: "running";
+                live: "live";
+            }>;
+            step: z.ZodEnum<{
+                publish: "publish";
+                reserve: "reserve";
+                database: "database";
+                "sign-in": "sign-in";
+            }>;
+            error: z.ZodNullable<z.ZodString>;
+            byEmail: z.ZodString;
+            restoredFrom: z.ZodNullable<z.ZodNumber>;
+            isStarter: z.ZodBoolean;
+            startedAt: z.ZodString;
+            finishedAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+    };
+    readonly logins: {
+        readonly read: NoInfer<import("./services.ts").ServiceCall<"/cli/logins/:approval", {}, z.ZodObject<{
+            code: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strip>>>;
+        readonly approve: NoInfer<import("./services.ts").ServiceCall<"/cli/logins/:approval/approve", {}, z.ZodObject<{
+            ok: z.ZodBoolean;
+        }, z.core.$strip>>>;
+    };
+};

package/dist/publishWire.js

@@ -0,0 +1,168 @@
+import { z } from 'zod';
+import { appTitle } from "./appTitle.js";
+export { appTitle };
+import { call, defineServices } from "./services.js";
+export const DASHBOARD_URL = 'https://onpattern.app';
+export const APPS_DOMAIN = 'onpattern.app';
+export const UPLOAD_LIMIT_BYTES = 50 * 1024 * 1024;
+export const UPLOAD_LIMIT_PARTS = 5000;
+const RESERVED_NAMES = new Set([
+    'auth',
+    'www',
+    'api',
+    'admin',
+    'app',
+    'apps',
+    'dashboard',
+    'deploy',
+    'publish',
+    'onpattern',
+    'trypattern',
+    'mail',
+    'login',
+    'help',
+    'docs',
+    'status',
+    'support',
+    'blog',
+    'dev',
+    'test',
+    'staging',
+    'cdn',
+    'static',
+    'assets',
+    'dispatch',
+    'start',
+    'approve'
+]);
+export function nameProblem(name) {
+    if (!/^[a-z][a-z0-9-]{1,28}[a-z0-9]$/.test(name)) {
+        return 'Use 3 to 30 lowercase letters, numbers and hyphens, starting with a letter.';
+    }
+    if (name.includes('--'))
+        return 'Use one hyphen at a time.';
+    if (RESERVED_NAMES.has(name) || name.startsWith('pattern')) {
+        return 'That address is reserved.';
+    }
+    return undefined;
+}
+export const appName = z.string().superRefine((name, context) => {
+    const problem = nameProblem(name);
+    if (problem !== undefined)
+        context.addIssue({ code: 'custom', message: problem });
+});
+export function hostnameOf(name) {
+    return `${name}.${APPS_DOMAIN}`;
+}
+const PRIVATE_NAMES = new Set([
+    '.git',
+    'node_modules',
+    'dist',
+    '.dev',
+    '.wrangler',
+    '.dev.vars',
+    '.DS_Store'
+]);
+export function isPrivatePath(path) {
+    return path.split('/').some((part) => {
+        if (PRIVATE_NAMES.has(part))
+            return true;
+        if (part.startsWith('.env') && part !== '.env.example')
+            return true;
+        return part.endsWith('.local') || part.endsWith('.log');
+    });
+}
+export function sourcePathProblem(path) {
+    if (path === '' || path.startsWith('/') || path.includes('\\')) {
+        return `${path} is not a relative path`;
+    }
+    if (path.split('/').some((part) => part === '' || part === '.' || part === '..')) {
+        return `${path} leaves the project`;
+    }
+    if (isPrivatePath(path))
+        return `${path} must never leave the laptop`;
+    return undefined;
+}
+export const UPLOAD = {
+    worker: 'worker/',
+    client: 'client/',
+    migrations: 'migrations/',
+    source: 'source/',
+    compatibilityDate: 'compatibilityDate',
+    sdkVersion: 'sdkVersion'
+};
+export const publishStep = z.enum(['reserve', 'database', 'sign-in', 'publish']);
+export const publishStatus = z.enum(['running', 'live', 'failed']);
+export const publishSummary = z.object({
+    number: z.number(),
+    status: publishStatus,
+    step: publishStep,
+    error: z.string().nullable(),
+    byEmail: z.string(),
+    restoredFrom: z.number().nullable(),
+    isStarter: z.boolean(),
+    startedAt: z.string(),
+    finishedAt: z.string().nullable()
+});
+export const appSummary = z.object({
+    name: z.string(),
+    title: z.string(),
+    url: z.string(),
+    pulledAt: z.string().nullable(),
+    latest: publishSummary.nullable()
+});
+export const nameSuggestion = z.object({
+    name: z.string(),
+    available: z.boolean(),
+    problem: z.string().nullable()
+});
+export const loginStarted = z.object({
+    secret: z.string(),
+    code: z.string(),
+    url: z.string()
+});
+export const loginPoll = z.union([
+    z.object({ status: z.literal('waiting') }),
+    z.object({ status: z.literal('approved'), cookie: z.string() })
+]);
+export const loginToApprove = z.object({ code: z.string(), label: z.string() });
+export const publishServices = defineServices({
+    apps: {
+        list: call({ get: '/apps', reply: z.array(appSummary) }),
+        read: call({ get: '/apps/:name', reply: appSummary }),
+        create: call({
+            post: '/apps',
+            input: { name: appName, title: appTitle },
+            reply: appSummary
+        })
+    },
+    names: {
+        suggest: call({
+            get: '/names',
+            input: { title: z.string() },
+            reply: z.array(nameSuggestion)
+        }),
+        check: call({ get: '/names/:name', reply: nameSuggestion })
+    },
+    publishes: {
+        list: call({
+            get: '/apps/:name/publishes',
+            reply: z.array(publishSummary)
+        }),
+        read: call({
+            get: '/apps/:name/publishes/:number',
+            reply: publishSummary
+        }),
+        retry: call({
+            post: '/apps/:name/publishes/:number/retry',
+            reply: publishSummary
+        })
+    },
+    logins: {
+        read: call({ get: '/cli/logins/:approval', reply: loginToApprove }),
+        approve: call({
+            post: '/cli/logins/:approval/approve',
+            reply: z.object({ ok: z.boolean() })
+        })
+    }
+});

package/dist/react.d.ts

@@ -10,6 +10,7 @@ export { CommandPalette } from './components/CommandPalette.tsx';
 export type { CommandMenuItem } from './components/CommandMenu.tsx';
 export { Content } from './components/Content.tsx';
 export { ContextMenu } from './components/ContextMenu.tsx';
+export { CopyButton } from './components/CopyButton.tsx';
 export { Dialog } from './components/Dialog.tsx';
 export { Divider } from './components/Divider.tsx';
 export { EmptyState } from './components/EmptyState.tsx';
@@ -26,6 +27,8 @@ export type { MenuEntry } from './components/MenuItems.tsx';
 export type { SidebarLink } from './components/Sidebar.tsx';
 export type { Placement } from './components/Placement.ts';
 export { PropertyRow } from './components/PropertyRow.tsx';
+export { RadioGroup } from './components/RadioGroup.tsx';
+export type { RadioOption } from './components/RadioGroup.tsx';
 export { Row } from './components/Row.tsx';
 export { Screen } from './components/Screen.tsx';
 export { ScrollArea } from './components/ScrollArea.tsx';

package/dist/react.js

@@ -9,6 +9,7 @@ export { CommandMenu } from "./components/CommandMenu.js";
 export { CommandPalette } from "./components/CommandPalette.js";
 export { Content } from "./components/Content.js";
 export { ContextMenu } from "./components/ContextMenu.js";
+export { CopyButton } from "./components/CopyButton.js";
 export { Dialog } from "./components/Dialog.js";
 export { Divider } from "./components/Divider.js";
 export { EmptyState } from "./components/EmptyState.js";
@@ -21,6 +22,7 @@ export { ListRow } from "./components/ListRow.js";
 export { LoadingRows } from "./components/LoadingRows.js";
 export { Menu } from "./components/Menu.js";
 export { PropertyRow } from "./components/PropertyRow.js";
+export { RadioGroup } from "./components/RadioGroup.js";
 export { Row } from "./components/Row.js";
 export { Screen } from "./components/Screen.js";
 export { ScrollArea } from "./components/ScrollArea.js";

package/dist/registered.d.ts

@@ -1,9 +1,11 @@
 import type { AppSnapshotShape, ModelServicesOf, NavigateCommand, PressKeyCommand, StoreClasses, StoreInstances, StoresOf } from './app.ts';
 import { z } from 'zod';
 import type { Action, DefineActions } from './actions.ts';
+import type { ServiceClient, Services } from './services.ts';
 import type { Instances, MessagesOf, ModelClassLike, ModelSnapshots } from './model.ts';
 import type { BUILT_IN_GROUPS } from './builtins/actions.ts';
 import type { Account } from './builtins/Account.ts';
+import type { AppSettings } from './builtins/AppSettings.ts';
 import type { Palette } from './builtins/Palette.ts';
 import type { SignIn } from './builtins/SignIn.ts';
 import type { IconName } from './components/icons.ts';
@@ -16,6 +18,8 @@ type Empty = Record<never, never>;
 type RegisteredModels = Registered<'models', Empty> extends infer Classes extends Record<string, ModelClassLike> ? Classes : Empty;
 type RegisteredTables = Registered<'tables', Empty> extends infer Group extends Tables ? Group : Empty;
 type RegisteredStores = Registered<'stores', Empty> extends infer Classes extends StoreClasses ? Classes : Empty;
+type RegisteredServices = Registered<'services', Empty> extends infer Group extends Services ? Group : Empty;
+export type AppServices = ServiceClient<RegisteredServices>;
 type RegisteredActionGroups = Registered<'actionGroups', readonly string[]> extends infer Groups extends readonly string[] ? Groups : readonly string[];
 export type AppActionGroup = RegisteredActionGroups[number] | (typeof BUILT_IN_GROUPS)[number];
 export type AppAction = Action & {
@@ -28,6 +32,7 @@ type RegisteredIcons = Registered<'icons', Empty> extends infer Icons extends Re
 export type AppIconName = keyof RegisteredIcons & string;
 export type BuiltInModels = {
     account: typeof Account;
+    appSettings: typeof AppSettings;
     palette: typeof Palette;
     signIn: typeof SignIn;
 };
@@ -43,6 +48,7 @@ export type ActionContext = {
 };
 export type ModelServices = ModelServicesOf<AppPath>;
 export declare const Model: <S extends import("./state.ts").StateSpec = Record<never, never>, const P extends readonly (keyof S & string)[] = []>(config?: import("./model.ts").ModelConfig<S, P>) => import("./model.ts").ModelClass<AppStores, ModelServices, S, P>;
+export declare const Store: <S extends import("./state.ts").StateSpec = Record<never, never>, const P extends readonly (keyof S & string)[] = []>(config: import("./store.ts").StoreConfig<S, P>) => import("./store.ts").StoreClass<S, P, ServiceClient<Empty>>;
 export declare const defineActions: DefineActions<ActionContext, RegisteredAction, AppCommand>;
 export declare const appPath: z.ZodCustom<AppPath, AppPath>;
 type ActionInput = Pick<AppAction, 'id' | 'label' | 'group' | 'icon'> & Partial<Pick<AppAction, 'keys' | 'keywords' | 'isDanger' | 'isSearchOnly' | 'isHidden'>> & {

package/dist/registered.js

@@ -1,8 +1,10 @@
 import { z } from 'zod';
 import { bindActions } from "./actions.js";
 import { defineModel } from "./model.js";
+import { defineStore } from "./store.js";
 import { isRoutedPath } from "./routes.js";
 export const Model = defineModel();
+export const Store = defineStore();
 export const defineActions = bindActions();
 export const appPath = z.custom((value) => typeof value === 'string' && isRoutedPath(value), { error: 'Not a page in src/routes.tsx' });
 export function action(input) {