@trypattern/sdk 0.1.12 → 0.1.13

package/dist/components/Text.js

@@ -1,6 +1,6 @@
 import * as stylex from '@stylexjs/stylex';
 import { createElement } from 'react';
-import { breakpoints, fontSizes, fontWeights, fonts, lineHeights } from "../theme/tokens.stylex.js";
+import { breakpoints, fontSizes, fontWeights, fonts, lineHeights, trackings } from "../theme/tokens.stylex.js";
 import { tones } from "./tones.js";
 export function Text({ children, variant = 'body', tone = 'inherit', align, as = 'span', isTruncated = false, isSelectable = false, style }) {
     return createElement(as, stylex.props(as !== 'span' && styles.block, variants[variant], tones[tone], align !== undefined && alignments[align], isTruncated && styles.truncated, isSelectable && styles.selectable, style), children);
@@ -21,11 +21,47 @@ const styles = stylex.create({
     }
 });
 const variants = stylex.create({
+    hero: {
+        fontSize: {
+            default: fontSizes.heading1,
+            [breakpoints.compact]: fontSizes.heading2
+        },
+        fontWeight: fontWeights.medium,
+        lineHeight: {
+            default: lineHeights.heading1,
+            [breakpoints.compact]: lineHeights.heading2
+        },
+        letterSpacing: trackings.hero
+    },
+    display: {
+        fontSize: {
+            default: fontSizes.heading2,
+            [breakpoints.compact]: fontSizes.heading3
+        },
+        fontWeight: fontWeights.medium,
+        lineHeight: {
+            default: lineHeights.heading2,
+            [breakpoints.compact]: lineHeights.heading3
+        },
+        letterSpacing: trackings.display
+    },
+    section: {
+        fontSize: {
+            default: fontSizes.heading3,
+            [breakpoints.compact]: fontSizes.heading5
+        },
+        fontWeight: fontWeights.medium,
+        lineHeight: {
+            default: lineHeights.heading3,
+            [breakpoints.compact]: lineHeights.heading5
+        },
+        letterSpacing: trackings.section
+    },
     heading: {
         fontSize: fontSizes.heading5,
         fontWeight: fontWeights.medium,
         lineHeight: lineHeights.heading5,
-        letterSpacing: '-0.01em'
+        letterSpacing: trackings.heading
     },
     subheading: {
         fontSize: fontSizes.heading6,
@@ -42,6 +78,11 @@ const variants = stylex.create({
         fontWeight: fontWeights.normal,
         lineHeight: lineHeights.body
     },
+    intro: {
+        fontSize: fontSizes.bodyLg,
+        fontWeight: fontWeights.normal,
+        lineHeight: lineHeights.bodyLg
+    },
     label: {
         fontSize: {
             default: fontSizes.bodySm,

package/dist/components/calendarDates.d.ts

@@ -0,0 +1,14 @@
+export declare function monthOf(date: string): string;
+export declare function addDays(date: string, days: number): string;
+export declare function addMonths(date: string, months: number): string;
+export declare function daysIn(month: string): number;
+export declare function weekdayIndex(date: string): number;
+export declare function weeksOf(month: string): readonly (readonly (string | null)[])[];
+export declare function localToday(): string;
+export declare function monthTitle(month: string, locale: string | undefined): string;
+export declare function dayLabel(date: string, locale: string | undefined): string;
+export declare function dayNumber(date: string, locale: string | undefined): string;
+export declare function weekdayNames(locale: string | undefined): readonly {
+    short: string;
+    long: string;
+}[];

package/dist/components/calendarDates.js

@@ -0,0 +1,84 @@
+const DAY_MS = 24 * 60 * 60 * 1000;
+function utc(date) {
+    return new Date(`${date}T00:00:00Z`);
+}
+function isoDate(time) {
+    return new Date(time).toISOString().slice(0, 10);
+}
+export function monthOf(date) {
+    return date.slice(0, 7);
+}
+export function addDays(date, days) {
+    return isoDate(utc(date).getTime() + days * DAY_MS);
+}
+export function addMonths(date, months) {
+    const start = utc(date);
+    const year = start.getUTCFullYear();
+    const month = start.getUTCMonth() + months;
+    const last = new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
+    return isoDate(Date.UTC(year, month, Math.min(start.getUTCDate(), last)));
+}
+export function daysIn(month) {
+    const start = utc(`${month}-01`);
+    return new Date(Date.UTC(start.getUTCFullYear(), start.getUTCMonth() + 1, 0)).getUTCDate();
+}
+export function weekdayIndex(date) {
+    return (utc(date).getUTCDay() + 6) % 7;
+}
+export function weeksOf(month) {
+    const first = `${month}-01`;
+    const cells = [
+        ...Array.from({ length: weekdayIndex(first) }, () => null),
+        ...Array.from({ length: daysIn(month) }, (_, index) => addDays(first, index))
+    ];
+    const weeks = [];
+    for (let index = 0; index < cells.length; index += 7) {
+        weeks.push(cells.slice(index, index + 7));
+    }
+    return weeks;
+}
+export function localToday() {
+    const now = new Date();
+    return [
+        String(now.getFullYear()).padStart(4, '0'),
+        String(now.getMonth() + 1).padStart(2, '0'),
+        String(now.getDate()).padStart(2, '0')
+    ].join('-');
+}
+export function monthTitle(month, locale) {
+    return new Intl.DateTimeFormat(locale, {
+        month: 'long',
+        year: 'numeric',
+        timeZone: 'UTC'
+    }).format(utc(`${month}-01`));
+}
+export function dayLabel(date, locale) {
+    return new Intl.DateTimeFormat(locale, {
+        dateStyle: 'full',
+        timeZone: 'UTC'
+    }).format(utc(date));
+}
+export function dayNumber(date, locale) {
+    return new Intl.DateTimeFormat(locale, {
+        day: 'numeric',
+        timeZone: 'UTC'
+    }).format(utc(date));
+}
+export function weekdayNames(locale) {
+    const monday = '2024-01-01';
+    const short = new Intl.DateTimeFormat(locale, {
+        weekday: 'short',
+        timeZone: 'UTC'
+    });
+    const long = new Intl.DateTimeFormat(locale, {
+        weekday: 'long',
+        timeZone: 'UTC'
+    });
+    return Array.from({ length: 7 }, (_, index) => {
+        const day = utc(addDays(monday, index));
+        return {
+            short: [...short.format(day)].slice(0, 2).join(''),
+            long: long.format(day)
+        };
+    });
+}

package/dist/components/controlLook.js

@@ -1,44 +1,44 @@
 import * as stylex from '@stylexjs/stylex';
-import { borders, colors, controls, fontSizes, lineHeights, motion, radii } from "../theme/tokens.stylex.js";
+import { borders, colors, controls, motion, radii } from "../theme/tokens.stylex.js";
 export const controlSizes = stylex.create({
     xs: {
         gap: controls.gapXs,
         height: controls.heightXs,
         paddingInline: controls.paddingXs,
-        fontSize: fontSizes.captionLg,
-        lineHeight: lineHeights.caption,
+        fontSize: controls.fontSizeXs,
+        lineHeight: controls.lineHeightXs,
         borderRadius: radii.sm
     },
     sm: {
         gap: controls.gapSm,
         height: controls.heightSm,
         paddingInline: controls.paddingSm,
-        fontSize: fontSizes.bodySm,
-        lineHeight: lineHeights.bodySm,
+        fontSize: controls.fontSizeSm,
+        lineHeight: controls.lineHeightSm,
         borderRadius: radii.md
     },
     md: {
         gap: controls.gapMd,
         height: controls.heightMd,
         paddingInline: controls.paddingMd,
-        fontSize: fontSizes.bodySm,
-        lineHeight: lineHeights.bodySm,
+        fontSize: controls.fontSizeMd,
+        lineHeight: controls.lineHeightMd,
         borderRadius: radii.md
     },
     lg: {
         gap: controls.gapLg,
         height: controls.heightLg,
         paddingInline: controls.paddingLg,
-        fontSize: fontSizes.bodySm,
-        lineHeight: lineHeights.bodySm,
+        fontSize: controls.fontSizeLg,
+        lineHeight: controls.lineHeightLg,
         borderRadius: radii.lg
     },
     xl: {
         gap: controls.gapXl,
         height: controls.heightXl,
         paddingInline: controls.paddingXl,
-        fontSize: fontSizes.bodySm,
-        lineHeight: lineHeights.bodySm,
+        fontSize: controls.fontSizeXl,
+        lineHeight: controls.lineHeightXl,
         borderRadius: radii.lg
     }
 });

package/dist/components/icons.d.ts

@@ -33,6 +33,8 @@ declare const builtInIcons: {
     alertCircle: string[];
     chevronDown: string;
     chevronRight: string;
+    previous: string;
+    next: string;
     search: string[];
     panelLeft: string[];
     more: {

package/dist/components/icons.js

@@ -62,6 +62,8 @@ const builtInIcons = {
     ],
     chevronDown: 'M7 10l5 5 5-5',
     chevronRight: 'M10 7l5 5-5 5',
+    previous: 'M15 18l-6-6 6-6',
+    next: 'M9 18l6-6-6-6',
     search: ['M4.5 11a6.5 6.5 0 1 0 13 0a6.5 6.5 0 1 0 -13 0', 'M16 16l4 4'],
     panelLeft: [
         'M6.5 4.5h11a3 3 0 0 1 3 3v9a3 3 0 0 1 -3 3h-11a3 3 0 0 1 -3 -3v-9a3 3 0 0 1 3 -3Z',

package/dist/components/interaction.d.ts

@@ -1,6 +1,6 @@
 import type { ReactNode } from 'react';
 export type Interaction = {
-    primitive: 'AppFrame' | 'Button' | 'Card' | 'IconButton' | 'Link' | 'ListRow' | 'Select' | 'Switch' | 'Checkbox' | 'SegmentedControl' | 'Menu' | 'ContextMenu' | 'CommandMenu' | 'TextField' | 'Form' | 'Dialog' | 'RadioGroup' | 'ChoiceGroup';
+    primitive: 'AppFrame' | 'Button' | 'Card' | 'IconButton' | 'Link' | 'ListRow' | 'Select' | 'Switch' | 'Checkbox' | 'SegmentedControl' | 'Menu' | 'ContextMenu' | 'CommandMenu' | 'TextField' | 'Form' | 'Dialog' | 'RadioGroup' | 'ChoiceGroup' | 'Calendar';
     event: 'click' | 'change' | 'select' | 'open' | 'close' | 'submit' | 'navigate';
     label: string;
     page: string | null;

package/dist/flows/browser.d.ts

@@ -31,4 +31,10 @@ export type AppPage = {
     captureAt: (viewport: ViewportName) => Promise<string>;
     close: () => Promise<void>;
 };
-export declare function openApp(browser: Browser, baseUrl: string, path: string, viewport: ViewportName, signedInAs: string | null, seed?: object, admins?: readonly string[], world?: unknown): Promise<AppPage>;
+export type MemoryRun = {
+    seed: object;
+    admins: readonly string[];
+    title: string;
+    world: unknown;
+};
+export declare function openApp(browser: Browser, baseUrl: string, path: string, viewport: ViewportName, signedInAs: string | null, memory?: MemoryRun): Promise<AppPage>;

package/dist/flows/browser.js

@@ -59,15 +59,27 @@ function watchNetwork(page) {
         }
     };
 }
+function isMissingPage(response, page) {
+    const request = response.request();
+    return (request.isNavigationRequest() &&
+        request.frame() === page.mainFrame() &&
+        response.status() >= 400 &&
+        response.status() < 500);
+}
 function recordProblems(page, problems) {
+    const missingPages = new Set();
     const record = (problem) => {
         if (!problems.includes(problem))
             problems.push(problem);
     };
     page.on('console', (message) => {
-        if (message.type() === 'error') {
-            record(`console error: ${message.text()}`);
+        if (message.type() !== 'error')
+            return;
+        if (missingPages.has(message.location().url) &&
+            message.text().startsWith('Failed to load resource')) {
+            return;
         }
+        record(`console error: ${message.text()}`);
     });
     page.on('pageerror', (error) => {
         record(`uncaught page error: ${error.message}`);
@@ -76,12 +88,16 @@ function recordProblems(page, problems) {
         record(`request failed: ${request.method()} ${request.url()} (${request.failure()?.errorText ?? 'unknown'})`);
     });
     page.on('response', (response) => {
+        if (isMissingPage(response, page)) {
+            missingPages.add(response.url());
+            return;
+        }
         if (response.status() >= 400) {
             record(`request failed: ${response.request().method()} ${response.url()} (HTTP ${response.status()})`);
         }
     });
 }
-export async function openApp(browser, baseUrl, path, viewport, signedInAs, seed, admins = [], world = {}) {
+export async function openApp(browser, baseUrl, path, viewport, signedInAs, memory) {
     const { width, height, deviceScaleFactor } = viewports[viewport];
     const context = await browser.newContext({
         viewport: { width, height },
@@ -89,20 +105,22 @@ export async function openApp(browser, baseUrl, path, viewport, signedInAs, seed
         reducedMotion: 'reduce',
         colorScheme: 'light'
     });
-    if (signedInAs !== null) {
+    if (memory === undefined && signedInAs !== null) {
         const signIn = await context.request.post(new URL('/api/auth/dev-sign-in', baseUrl).href, { data: { email: signedInAs } });
         if (!signIn.ok()) {
             throw new Error(`Dev sign-in as ${signedInAs} failed (HTTP ${signIn.status()}): ${await signIn.text()}`);
         }
     }
-    if (seed !== undefined) {
+    if (memory !== undefined) {
         await context.addInitScript((value) => {
             Object.assign(globalThis, {
                 patternSeed: value.seed,
                 patternAdmins: value.admins,
-                patternWorld: value.world
+                patternTitle: value.title,
+                patternWorld: value.world,
+                patternSignedInAs: value.signedInAs
             });
-        }, { seed, admins, world });
+        }, { ...memory, signedInAs });
     }
     const page = await context.newPage();
     const problems = [];

package/dist/flows/flowBrowser.d.ts

@@ -1,4 +1,4 @@
-import type { ViewportName } from './browser.ts';
+import type { MemoryRun, ViewportName } from './browser.ts';
 export type VisualFlowSettings = {
     url: string;
     wsEndpoint: string;
@@ -11,7 +11,7 @@ declare module 'vitest' {
     }
 }
 export declare function closeFlowBrowser(): Promise<void>;
-export declare function openFlowPage(settings: VisualFlowSettings, viewport: ViewportName, startAt: string, signedInAs: string | null, seed: object, admins: readonly string[], world: unknown): Promise<{
+export declare function openFlowPage(settings: VisualFlowSettings, viewport: ViewportName, startAt: string, signedInAs: string | null, memory: MemoryRun): Promise<{
     send: (command: unknown) => Promise<void>;
     snapshot: () => Promise<unknown>;
     hold: (call: string) => Promise<void>;

package/dist/flows/flowBrowser.js

@@ -5,9 +5,9 @@ export async function closeFlowBrowser() {
     browser = undefined;
     await (await connected)?.close();
 }
-export async function openFlowPage(settings, viewport, startAt, signedInAs, seed, admins, world) {
+export async function openFlowPage(settings, viewport, startAt, signedInAs, memory) {
     browser ??= connectChrome(settings.wsEndpoint);
-    const app = await openApp(await browser, settings.url, startAt, viewport, signedInAs, seed, admins, world);
+    const app = await openApp(await browser, settings.url, startAt, viewport, signedInAs, memory);
     return {
         send: app.dispatch,
         snapshot: app.snapshot,

package/dist/flows/flows.js

@@ -59,6 +59,12 @@ async function runSteps(name, steps, run) {
         }
     }
 }
+function leadingHolds(steps) {
+    const firstOther = steps.findIndex((step) => !('hold' in step));
+    return steps
+        .slice(0, firstOther === -1 ? steps.length : firstOther)
+        .flatMap((step) => ('hold' in step ? [step.hold] : []));
+}
 function withTestParams(path, failing, held) {
     const params = new URLSearchParams([
         ['memory', ''],
@@ -133,8 +139,8 @@ export function defineFlow({ App }) {
         for (const viewport of visual.viewports) {
             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, startingWorld);
+                const held = new Set(leadingHolds(steps));
+                const page = await openFlowPage(visual, viewport, withTestParams(startAt, failing, held), signedInAs, { seed, admins, title, world: startingWorld });
                 let stepFailure;
                 try {
                     await runSteps(name, steps, {

package/dist/index.d.ts

@@ -1,4 +1,7 @@
 export { defineApp } from './app.ts';
+export { Bookings, bookings } from './bookingsStore.ts';
+export type { BookingsWorld } from './bookingsMemory.ts';
+export type { AppBlock } from './blocks.ts';
 export { ActionsStore, bindActions, rankActions } from './actions.ts';
 export type { Action, ActionsBuilder } from './actions.ts';
 export { startApp } from './start.ts';
@@ -16,7 +19,7 @@ export { HttpSessionApi, MemorySessionApi } from './auth/sessionApi.ts';
 export type { EmailCodeOutcome, SessionApi, SessionCall } from './auth/sessionApi.ts';
 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 type { AppClass, AppDefinition, AppDependencies, AppSnapshotShape, BlockStores, CheckedBlocks, 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';

package/dist/index.js

@@ -1,4 +1,5 @@
 export { defineApp } from "./app.js";
+export { Bookings, bookings } from "./bookingsStore.js";
 export { ActionsStore, bindActions, rankActions } from "./actions.js";
 export { startApp } from "./start.js";
 export { appearance } from "./appearance.js";

package/dist/media.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import type { Row } from './table.ts';
+import type { Fields, Row, Tables } from './table.ts';
 export declare const media: import("./table.ts").TableOf<"media", {
     readonly columns: {
         readonly key: z.ZodString;
@@ -20,6 +20,16 @@ export declare const media: import("./table.ts").TableOf<"media", {
 }>;
 export type Media = Row<typeof media>;
 export type MediaImage = Pick<Media, 'key' | 'width' | 'height' | 'placeholder' | 'alt'>;
+export type StarterPhoto = {
+    id: string;
+    photo: string;
+    alt: string;
+};
+export type Starter<Group extends Tables> = {
+    [Key in keyof Group as Group[Key]['owned'] extends true ? never : Key]?: Group[Key] extends typeof media ? readonly StarterPhoto[] : readonly ({
+        id: string;
+    } & Fields<Group[Key]>)[];
+};
 export declare const MEDIA_LIMIT_BYTES: number;
 export declare const IMAGE_WIDTHS: readonly [320, 640, 960, 1280, 1920];
 export declare function mediaPath(key: string): string;

package/dist/patternAccess.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 export declare const TABLES_READ = "tables:read";
+export declare const MEDIA_WRITE = "media:write";
 export declare const ASSERTION_SECONDS = 60;
 export declare const NEXT_PAGE_HEADER = "x-pattern-next";
 export declare const assertionKey: z.ZodObject<{
@@ -10,12 +11,20 @@ export declare const assertionKey: z.ZodObject<{
     d: z.ZodString;
 }, z.core.$strip>;
 export type AssertionKey = z.output<typeof assertionKey>;
-export declare function signTablesAssertion(key: AssertionKey, { sub, aud }: {
+declare const assertionScope: z.ZodEnum<{
+    "tables:read": "tables:read";
+    "media:write": "media:write";
+}>;
+export type AssertionScope = z.output<typeof assertionScope>;
+export declare function signAssertion(key: AssertionKey, { sub, aud, scope }: {
     sub: string;
     aud: string;
+    scope: AssertionScope;
 }, now: number): Promise<string>;
-export declare function verifiedTablesAssertion(token: string, { hostname, keys, now }: {
+export declare function verifiedAssertion(token: string, { hostname, keys, now, scope }: {
     hostname: string;
     keys: Readonly<Record<string, string>>;
     now: number;
+    scope: AssertionScope;
 }): Promise<string | undefined>;
+export {};

package/dist/patternAccess.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 export const TABLES_READ = 'tables:read';
+export const MEDIA_WRITE = 'media:write';
 export const ASSERTION_SECONDS = 60;
 export const NEXT_PAGE_HEADER = 'x-pattern-next';
 const CLOCK_SKEW_SECONDS = 30;
@@ -11,6 +12,7 @@ export const assertionKey = z.object({
     x: z.string(),
     d: z.string()
 });
+const assertionScope = z.enum([TABLES_READ, MEDIA_WRITE]);
 const assertionHeader = z.object({
     alg: z.literal('EdDSA'),
     typ: z.literal('JWT'),
@@ -19,7 +21,7 @@ const assertionHeader = z.object({
 const assertionClaims = z.object({
     sub: z.email(),
     aud: z.string(),
-    scope: z.literal(TABLES_READ),
+    scope: assertionScope,
     iat: z.int(),
     exp: z.int()
 });
@@ -53,12 +55,12 @@ function jsonOf(text) {
 function encoded(value) {
     return base64url(encoder.encode(JSON.stringify(value)));
 }
-export async function signTablesAssertion(key, { sub, aud }, now) {
+export async function signAssertion(key, { sub, aud, scope }, now) {
     const privateKey = await crypto.subtle.importKey('jwk', { kty: key.kty, crv: key.crv, x: key.x, d: key.d }, ED25519, false, ['sign']);
     const signed = `${encoded({ alg: 'EdDSA', typ: 'JWT', kid: key.kid })}.${encoded({
         sub,
         aud,
-        scope: TABLES_READ,
+        scope,
         iat: now,
         exp: now + ASSERTION_SECONDS
     })}`;
@@ -80,7 +82,7 @@ async function isSignedBy(publicKey, signed, signature) {
         return false;
     }
 }
-export async function verifiedTablesAssertion(token, { hostname, keys, now }) {
+export async function verifiedAssertion(token, { hostname, keys, now, scope }) {
     const [header, claims, signature, ...rest] = token.split('.');
     if (header === undefined ||
         claims === undefined ||
@@ -102,6 +104,8 @@ export async function verifiedTablesAssertion(token, { hostname, keys, now }) {
     if (!parsed.success)
         return undefined;
     const { sub, aud, iat, exp } = parsed.data;
+    if (parsed.data.scope !== scope)
+        return undefined;
     const isFresh = exp > iat &&
         exp - iat <= ASSERTION_SECONDS &&
         iat <= now + CLOCK_SKEW_SECONDS &&

package/dist/publishWire.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 import { appTitle } from './appTitle.ts';
 export { appTitle };
-export { ASSERTION_SECONDS, NEXT_PAGE_HEADER, TABLES_READ, assertionKey, signTablesAssertion } from './patternAccess.ts';
-export type { AssertionKey } from './patternAccess.ts';
+export { ASSERTION_SECONDS, MEDIA_WRITE, NEXT_PAGE_HEADER, TABLES_READ, assertionKey, signAssertion } from './patternAccess.ts';
+export type { AssertionKey, AssertionScope } from './patternAccess.ts';
 export declare const DASHBOARD_URL = "https://onpattern.app";
 export declare const APPS_DOMAIN = "onpattern.app";
 export declare const UPLOAD_LIMIT_BYTES: number;
@@ -21,7 +21,29 @@ export declare const UPLOAD: {
     readonly sdkVersion: "sdkVersion";
     readonly message: "message";
     readonly runWorkerFirst: "runWorkerFirst";
+    readonly starter: "starter";
 };
+export declare const starterContent: z.ZodObject<{
+    photos: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        alt: z.ZodString;
+    }, z.core.$strip>>;
+    sql: z.ZodString;
+}, z.core.$strip>;
+export type StarterContent = z.output<typeof starterContent>;
+export declare const mediaRow: z.ZodObject<{
+    id: z.ZodString;
+    key: z.ZodString;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    placeholder: z.ZodNullable<z.ZodString>;
+    alt: z.ZodString;
+    type: z.ZodString;
+    bytes: z.ZodNumber;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type MediaRow = z.output<typeof mediaRow>;
 export declare function workerFirstPaths(text: string | undefined): readonly string[];
 export declare const PUBLISH_MESSAGE_LIMIT = 100;
 export declare function publishMessage(text: string): string | null;

package/dist/publishWire.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { appTitle } from "./appTitle.js";
 export { appTitle };
-export { ASSERTION_SECONDS, NEXT_PAGE_HEADER, TABLES_READ, assertionKey, signTablesAssertion } from "./patternAccess.js";
+export { ASSERTION_SECONDS, MEDIA_WRITE, NEXT_PAGE_HEADER, TABLES_READ, assertionKey, signAssertion } from "./patternAccess.js";
 import { call, defineServices } from "./services.js";
 export const DASHBOARD_URL = 'https://onpattern.app';
 export const APPS_DOMAIN = 'onpattern.app';
@@ -92,8 +92,28 @@ export const UPLOAD = {
     compatibilityDate: 'compatibilityDate',
     sdkVersion: 'sdkVersion',
     message: 'message',
-    runWorkerFirst: 'runWorkerFirst'
+    runWorkerFirst: 'runWorkerFirst',
+    starter: 'starter'
 };
+export const starterContent = z.object({
+    photos: z.array(z.object({
+        id: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/),
+        path: z.string().startsWith('starter/photos/'),
+        alt: z.string().trim().min(1)
+    })),
+    sql: z.string()
+});
+export const mediaRow = z.object({
+    id: z.string(),
+    key: z.string(),
+    width: z.number(),
+    height: z.number(),
+    placeholder: z.string().nullable(),
+    alt: z.string(),
+    type: z.string(),
+    bytes: z.number(),
+    createdAt: z.string()
+});
 const WORKER_FIRST_PATH = /^!?\/[\w.~\-/*]{0,100}$/;
 const WORKER_FIRST_LIMIT = 32;
 const ALWAYS_WORKER_FIRST = ['/api/*', '/media/*'];

package/dist/react.d.ts

@@ -5,6 +5,8 @@ export { AppearancePicker } from './components/AppearancePicker.tsx';
 export { Avatar } from './components/Avatar.tsx';
 export { Badge } from './components/Badge.tsx';
 export { Button } from './components/Button.tsx';
+export { Calendar } from './components/Calendar.tsx';
+export type { CalendarDay } from './components/Calendar.tsx';
 export { Card } from './components/Card.tsx';
 export { Checkbox } from './components/Checkbox.tsx';
 export { Choice } from './components/Choice.tsx';

package/dist/react.js

@@ -5,6 +5,7 @@ export { AppearancePicker } from "./components/AppearancePicker.js";
 export { Avatar } from "./components/Avatar.js";
 export { Badge } from "./components/Badge.js";
 export { Button } from "./components/Button.js";
+export { Calendar } from "./components/Calendar.js";
 export { Card } from "./components/Card.js";
 export { Checkbox } from "./components/Checkbox.js";
 export { Choice } from "./components/Choice.js";