@trypattern/sdk 0.1.12 → 0.1.13

package/dist/bookingsStore.js

@@ -0,0 +1,129 @@
+import { z } from 'zod';
+import { bookingDay, bookingRequests, bookingRulesReply, bookingServices, bookingSlot, bookingTables } from "./bookings.js";
+import { bookingMemory } from "./bookingsMemory.js";
+import { ServiceRefused } from "./services.js";
+import { defineStore } from "./store.js";
+const Store = defineStore();
+const OUTCOMES = {
+    401: 'forbidden',
+    403: 'forbidden',
+    404: 'missing',
+    409: 'conflict'
+};
+function outcomeOf(error) {
+    return error instanceof ServiceRefused
+        ? (OUTCOMES[error.status] ?? 'failed')
+        : 'failed';
+}
+const loadStatus = z.enum(['idle', 'loading', 'ready', 'failed']);
+export class Bookings extends Store({
+    state: {
+        days: z.record(z.string(), z.array(bookingDay)).default({}),
+        windows: z.record(z.string(), z.array(bookingSlot)).default({}),
+        requests: z.array(bookingRequests.row).default([]),
+        requestsStatus: loadStatus.default('idle'),
+        rules: bookingRulesReply.nullable().default(null),
+        sent: bookingRequests.row.nullable().default(null),
+        isSending: z.boolean().default(false)
+    }
+}) {
+    async loadDays(month) {
+        try {
+            const days = await this.services.bookings.days({ month });
+            this.set({ days: { ...this.state.days, [month]: days } });
+        }
+        catch {
+            return;
+        }
+    }
+    async loadWindows(date) {
+        try {
+            const windows = await this.services.bookings.windows({ date });
+            this.set({ windows: { ...this.state.windows, [date]: windows } });
+        }
+        catch {
+            return;
+        }
+    }
+    async request(fields) {
+        this.set({ isSending: true });
+        try {
+            const sent = await this.services.bookings.request(fields);
+            this.set({ sent });
+            return 'saved';
+        }
+        catch (error) {
+            return outcomeOf(error);
+        }
+        finally {
+            this.set({ isSending: false });
+            await Promise.all([
+                this.loadDays(fields.date.slice(0, 7)),
+                this.loadWindows(fields.date)
+            ]);
+        }
+    }
+    forgetSent() {
+        this.set({ sent: null });
+    }
+    async loadRequests() {
+        if (this.state.requestsStatus !== 'ready') {
+            this.set({ requestsStatus: 'loading' });
+        }
+        try {
+            const requests = await this.services.bookings.requests();
+            this.set({ requests, requestsStatus: 'ready' });
+        }
+        catch {
+            if (this.state.requestsStatus === 'loading') {
+                this.set({ requestsStatus: 'failed' });
+            }
+        }
+    }
+    accept(id) {
+        return this.#decide(id, () => this.services.bookings.accept({ id }));
+    }
+    decline(id) {
+        return this.#decide(id, () => this.services.bookings.decline({ id }));
+    }
+    async loadRules() {
+        try {
+            this.set({ rules: await this.services.bookings.rules() });
+        }
+        catch {
+            return;
+        }
+    }
+    async saveRules(rules) {
+        try {
+            this.set({
+                rules: await this.services.bookings.saveRules(rules),
+                days: {},
+                windows: {}
+            });
+            return 'saved';
+        }
+        catch (error) {
+            return outcomeOf(error);
+        }
+    }
+    async #decide(id, send) {
+        try {
+            const decided = await send();
+            this.set({
+                requests: this.state.requests.map((request) => request.id === id ? decided : request)
+            });
+            return 'saved';
+        }
+        catch (error) {
+            return outcomeOf(error);
+        }
+    }
+}
+export const bookings = {
+    name: 'bookings',
+    tables: bookingTables,
+    services: bookingServices,
+    memory: bookingMemory,
+    Store: Bookings
+};

package/dist/cli/app.js

@@ -16,8 +16,10 @@ import { createHash } from 'node:crypto';
 import { z } from 'zod';
 import { MEDIA_LIMIT_BYTES } from "../media.js";
 import { isHeic } from "../server/imageHeader.js";
-import { resetLocalDatabase } from "../vite/localWorker.js";
-import { login, publish, pull, restore, versions as listVersions } from "./publishing.js";
+import { putLocalPhotos, resetLocalDatabase } from "../vite/localWorker.js";
+import { readProjectFile } from "../vite/projectFile.js";
+import { readStarter, starterContentOf, withStarter } from "./starter.js";
+import { addLiveMedia, login, publish, pull, restore, versions as listVersions } from "./publishing.js";
 import { toolBin } from "./tools.js";
 function dependsOnPattern(directory) {
     try {
@@ -93,7 +95,7 @@ const PHOTO_TYPES = {
     '.avif': 'image/avif'
 };
 const HEIC_EXTENSIONS = new Set(['.heic', '.heif']);
-const MEDIA_USAGE = '  usage  app media add photo.jpg --alt "Pink peonies in a glass vase"';
+const MEDIA_USAGE = '  usage  app media add photo.jpg --alt "Pink peonies in a glass vase" [--live]';
 const SHIM_SOURCE = `#!/bin/sh
 ${SHIM_MARKER_LINE}
 dir=$PWD
@@ -193,10 +195,11 @@ app check format and app check lint pass for anything a tool can fix by itself.`
         run: fix
     },
     reset: {
-        summary: 'Empty the local database and fill it again from seed.ts',
+        summary: 'Empty the local database and fill it again from seed.ts and starter/',
         details: `Deletes every row in every table of the local database (signed-in users stay) and inserts
-the rows in seed.ts again. app start only fills an empty table, so run this after changing seed.ts.
-Works while the dev server runs; reload the page to see the new rows.`,
+the rows in seed.ts again, with the rows in starter/rows.ts and their photos from starter/photos,
+which go into the local MEDIA bucket. app start only fills an empty table, so run this after
+changing seed.ts or starter/. Works while the dev server runs; reload the page to see the new rows.`,
         run: reset
     },
     migration: {
@@ -209,12 +212,18 @@ migrations to the local database. Prints "No schema changes" when the migrations
         takesArgument: true
     },
     media: {
-        summary: 'Add a photo to the media table: app media add photo.jpg --alt "…"',
+        summary: 'Add a photo to the media table: app media add photo.jpg --alt "…" [--live]',
         details: `app media add photo.jpg --alt "Pink peonies in a glass vase"
+app media add photo.jpg --alt "Pink peonies in a glass vase" --live
 Sends the photo to the dev server's POST /api/media, signed in as the first email in admins in
 schema.ts (dev sign-in, so this adds to the local database and the local MEDIA bucket). The server
 reads its width and height, stores it as images/<hash>.<ext> and adds a row to the media table;
-this prints the row. Show it with <Image image={row} sizes="…" />.
+this prints the row and its id. Show it with <Image image={row} sizes="…" />.
+Without --live the photo stays on this computer, and this says so.
+--live first sends it to the live site, <name>.onpattern.app, through onpattern.app (signing in
+like app publish), whose own POST /api/media works out its size, placeholder and alt the same way,
+then adds it to the local database too under the same id, so both show it at once. Putting it on a
+live item is the owner's change to make on the live site; the local photo only shows it here.
 --alt is required: describe the photo for someone who can't see it.
 JPEG, PNG, WebP, GIF or AVIF, up to 10 MB. iPhone HEIC photos are refused: convert one first with
 sips -s format jpeg photo.heic --out photo.jpg. The app's tables must include media from
@@ -222,7 +231,7 @@ sips -s format jpeg photo.heic --out photo.jpg. The app's tables must include me
 run_worker_first. Uses the running dev server, or starts one and stops it afterwards.`,
         run: (_argument, options, rest) => addMedia(rest, options),
         argumentCount: 2,
-        flags: ['--alt']
+        flags: ['--alt', '--live']
     },
     build: {
         summary: 'Build the app for production into dist/',
@@ -321,10 +330,21 @@ moves forward with any new migrations; nothing is ever deleted from it. If a ste
 keeps running the previous version and the error says why. Run app check first.
 --message '…' says what changed in a few plain words for the owner ("Pink brand colour and a welcome
 line"); onpattern.app and app versions show it beside the version.
---starter (Pattern's admins only) publishes this project as the starter every new site begins from.`,
-        run: (_argument, options) => {
+--starter (Pattern's admins only) publishes this project as the starter every new site begins from.
+With a starter/ folder, its rows (starter/rows.ts) and photos (starter/photos) go with it, and a new
+site's first publish puts them in its own database and photo bucket: the photos through the site's
+own POST /api/media, then the rows. Later publishes never touch them; they are the owner's.`,
+        run: async (_argument, options) => {
             const message = options.get('--message');
-            return publish(publishingIo(), ROOT, options.has('--starter'), typeof message === 'string' ? message : undefined);
+            const isStarter = options.has('--starter');
+            let starter;
+            try {
+                starter = isStarter ? await starterToPublish() : undefined;
+            }
+            catch (error) {
+                return mediaRefusal(`The starter can't go out: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return publish(publishingIo(), ROOT, isStarter, typeof message === 'string' ? message : undefined, starter);
         },
         flags: ['--starter', '--message']
     },
@@ -353,7 +373,7 @@ existing ${SHIM_PATH} that was not installed by Pattern.`,
     },
     help: {
         summary: 'Show this help (`app <command> --help` for details)',
-        details: 'Lists commands. Flags: --json (machine-readable stdout), --help, --no-open (start only), --visual (test only), --commands, --name, --as and --signed-out (screenshot only), --alt (media only).',
+        details: 'Lists commands. Flags: --json (machine-readable stdout), --help, --no-open (start only), --visual (test only), --commands, --name, --as and --signed-out (screenshot only), --alt and --live (media only).',
         run: help
     }
 };
@@ -693,7 +713,22 @@ async function projectData() {
     if (typeof seed !== 'object' || seed === null) {
         throw new Error('seed.ts must export `seed`');
     }
-    return { tables: tables, seed };
+    const starter = await readStarter(ROOT, tables);
+    return {
+        tables: tables,
+        seed: withStarter(seed, starter),
+        photos: starter?.photos ?? []
+    };
+}
+async function starterToPublish() {
+    const tables = await importExport('schema.ts', 'tables');
+    if (typeof tables !== 'object' || tables === null) {
+        throw new Error('schema.ts must export `tables`');
+    }
+    const starter = await readStarter(ROOT, tables);
+    return starter === undefined
+        ? undefined
+        : starterContentOf(tables, starter);
 }
 function fingerprint(seed) {
     return createHash('sha256').update(JSON.stringify(seed)).digest('hex');
@@ -714,18 +749,22 @@ async function seedChangedNotice() {
         : undefined;
     return previous === fingerprint(seed)
         ? undefined
-        : '  seed  seed.ts changed since the local database was filled; app reset fills it again';
+        : '  seed  seed.ts or starter/ changed since the local database was filled; app reset fills it again';
 }
 async function reset() {
     try {
-        const { tables, seed } = await projectData();
+        const { tables, seed, photos } = await projectData();
         resetLocalDatabase(ROOT, tables, seed);
+        putLocalPhotos(ROOT, photos);
         recordSeed(seed);
         const rows = Object.values(seed).reduce((total, list) => total + (list?.length ?? 0), 0);
+        const from = existsSync(join(ROOT, 'starter'))
+            ? 'seed.ts and starter/'
+            : 'seed.ts';
         return {
             code: 0,
-            data: { rows },
-            text: `✓ Local database emptied and filled with the ${rows} rows in seed.ts\n  next  reload the page`
+            data: { rows, photos: photos.length },
+            text: `✓ Local database emptied and filled with the ${rows} rows in ${from}\n  next  reload the page`
         };
     }
     catch (error) {
@@ -1255,35 +1294,20 @@ async function firstAdmin() {
     const first = Array.isArray(admins) ? admins[0] : undefined;
     return typeof first === 'string' ? first : undefined;
 }
-async function addMedia(args, options) {
-    const [action, file] = args;
-    if (action !== 'add' || file === undefined) {
-        return mediaRefusal(`Say which photo to add\n${MEDIA_USAGE}`, 2);
-    }
-    const alt = options.get('--alt');
-    if (typeof alt !== 'string' || alt.trim() === '') {
-        return mediaRefusal(`--alt is required: describe this photo for someone who can't see it\n${MEDIA_USAGE}`, 2);
-    }
-    const path = resolve(process.cwd(), file);
-    if (!existsSync(path))
-        return mediaRefusal(`There is no file at ${file}`);
-    const bytes = readFileSync(path);
-    const extension = extname(path).toLowerCase();
-    if (HEIC_EXTENSIONS.has(extension) || isHeic(bytes)) {
-        return mediaRefusal(`${file} is an iPhone HEIC photo, which browsers can't show. Convert it to JPEG, then add the JPEG:\n  sips -s format jpeg ${file} --out ${file.replace(/\.[^.]+$/, '')}-converted.jpg`);
-    }
-    const type = PHOTO_TYPES[extension];
-    if (type === undefined) {
-        return mediaRefusal(`${file} is not a photo the web can show: use JPEG, PNG, WebP, GIF or AVIF`);
-    }
-    if (bytes.byteLength > MEDIA_LIMIT_BYTES) {
-        return mediaRefusal(`${file} is over 10 MB: export it smaller first`);
-    }
+function photoForm(bytes, type, path, alt, id) {
+    const form = new FormData();
+    form.set('file', new Blob([bytes], { type }), basename(path));
+    form.set('alt', alt);
+    if (id !== undefined)
+        form.set('id', id);
+    return form;
+}
+async function addLocalMedia(form, file) {
     const admin = await firstAdmin();
     if (admin === undefined) {
-        return mediaRefusal("Only an admin can add photos: put the owner's email in admins in schema.ts");
+        return "only an admin can add photos: put the owner's email in admins in schema.ts";
     }
-    return withDevServer(async (url) => {
+    const outcome = await withDevServer(async (url) => {
         const origin = new URL(url).origin;
         const signedIn = await fetch(new URL('/api/auth/dev-sign-in', url), {
             method: 'POST',
@@ -1291,15 +1315,12 @@ async function addMedia(args, options) {
             body: JSON.stringify({ email: admin })
         });
         if (!signedIn.ok) {
-            return mediaRefusal(`Could not sign in as ${admin} (HTTP ${signedIn.status})`);
+            return mediaRefusal(`could not sign in as ${admin} (HTTP ${signedIn.status})`);
         }
         const cookie = signedIn.headers
             .getSetCookie()
             .map((line) => line.split(';')[0])
             .join('; ');
-        const form = new FormData();
-        form.set('file', new Blob([bytes], { type }), basename(path));
-        form.set('alt', alt.trim());
         const response = await fetch(new URL('/api/media', url), {
             method: 'POST',
             headers: { origin, cookie },
@@ -1307,25 +1328,88 @@ async function addMedia(args, options) {
         });
         const reply = await response.json().catch(() => undefined);
         if (response.status === 404) {
-            return mediaRefusal("This app has no media table: add media from '@trypattern/sdk/schema' to tables in schema.ts, run app migration add_media, and bind an R2 bucket as MEDIA in wrangler.jsonc");
+            return mediaRefusal("this app has no media table: add media from '@trypattern/sdk/schema' to tables in schema.ts, run app migration add_media, and bind an R2 bucket as MEDIA in wrangler.jsonc");
         }
         if (!response.ok) {
-            return mediaRefusal(`Could not add ${file}: ${replyError(reply) ?? `HTTP ${response.status}`}`);
+            return mediaRefusal(`could not add ${file}: ${replyError(reply) ?? `HTTP ${response.status}`}`);
         }
-        const row = Object(reply);
+        return { code: 0, data: { media: Object(reply) }, text: '' };
+    });
+    const row = outcome.data['media'];
+    return outcome.code === 0 && typeof row === 'object' && row !== null
+        ? row
+        : String(outcome.data['error'] ?? outcome.text);
+}
+function mediaLines(row) {
+    return [
+        `  id    ${String(row['id'])}`,
+        `  key   ${String(row['key'])}`,
+        `  size  ${String(row['width'])}×${String(row['height'])}`,
+        `  alt   ${String(row['alt'])}`
+    ];
+}
+async function addMedia(args, options) {
+    const [action, file] = args;
+    if (action !== 'add' || file === undefined) {
+        return mediaRefusal(`Say which photo to add\n${MEDIA_USAGE}`, 2);
+    }
+    const alt = options.get('--alt');
+    if (typeof alt !== 'string' || alt.trim() === '') {
+        return mediaRefusal(`--alt is required: describe this photo for someone who can't see it\n${MEDIA_USAGE}`, 2);
+    }
+    const path = resolve(process.cwd(), file);
+    if (!existsSync(path))
+        return mediaRefusal(`There is no file at ${file}`);
+    const bytes = readFileSync(path);
+    const extension = extname(path).toLowerCase();
+    if (HEIC_EXTENSIONS.has(extension) || isHeic(bytes)) {
+        return mediaRefusal(`${file} is an iPhone HEIC photo, which browsers can't show. Convert it to JPEG, then add the JPEG:\n  sips -s format jpeg ${file} --out ${file.replace(/\.[^.]+$/, '')}-converted.jpg`);
+    }
+    const type = PHOTO_TYPES[extension];
+    if (type === undefined) {
+        return mediaRefusal(`${file} is not a photo the web can show: use JPEG, PNG, WebP, GIF or AVIF`);
+    }
+    if (bytes.byteLength > MEDIA_LIMIT_BYTES) {
+        return mediaRefusal(`${file} is over 10 MB: export it smaller first`);
+    }
+    const said = alt.trim();
+    const site = `${readProjectFile(ROOT).name}.onpattern.app`;
+    if (!options.has('--live')) {
+        const row = await addLocalMedia(photoForm(bytes, type, path, said, undefined), file);
+        if (typeof row === 'string')
+            return mediaRefusal(`Could not add ${file}: ${row}`);
         return {
             code: 0,
-            data: { media: row },
+            data: { media: row, live: false },
             text: [
-                `✓ Added ${file} to media`,
-                `  id    ${String(row['id'])}`,
-                `  key   ${String(row['key'])}`,
-                `  size  ${String(row['width'])}×${String(row['height'])}`,
-                `  alt   ${String(row['alt'])}`,
+                `✓ Added ${file} to media on this computer`,
+                ...mediaLines(row),
+                `  live  not on ${site}: add --live to put it there too`,
                 '  show  <Image image={row} sizes="…" /> with that media row'
             ].join('\n')
         };
-    });
+    }
+    const live = await addLiveMedia(publishingIo(), ROOT, photoForm(bytes, type, path, said, undefined), `app media add ${file} --alt ${JSON.stringify(said)} --live`);
+    if (live.code !== 0)
+        return live;
+    const row = live.data['media'];
+    const local = await addLocalMedia(photoForm(bytes, type, path, said, String(row['id'])), file);
+    return {
+        code: 0,
+        data: {
+            media: row,
+            live: true,
+            local: typeof local === 'string' ? { error: local } : local
+        },
+        text: [
+            `✓ Added ${file} to media on ${site}${typeof local === 'string' ? '' : ' and on this computer'}`,
+            ...mediaLines(row),
+            ...(typeof local === 'string'
+                ? [`  local  not added on this computer: ${local}`]
+                : []),
+            `  next  the owner attaches it to an item on the live site's Manage page; Claude can't change live rows`
+        ].join('\n')
+    };
 }
 async function build() {
     let vite;
@@ -1441,7 +1525,7 @@ async function setup() {
 function help() {
     const width = Math.max(...Object.keys(COMMANDS).map((n) => n.length));
     const lines = Object.entries(COMMANDS).map(([name, cmd]) => `app ${name.padEnd(width)}  ${cmd.summary}`);
-    lines.push('Flags: --json (machine-readable stdout), <command> --help (details and its own flags: start --no-open, test --visual, screenshot --commands --name --as --signed-out, pull --code, publish --message, media --alt)');
+    lines.push('Flags: --json (machine-readable stdout), <command> --help (details and its own flags: start --no-open, test --visual, screenshot --commands --name --as --signed-out, pull --code, publish --message, media --alt --live)');
     return {
         code: 0,
         data: {

package/dist/cli/publishing.d.ts

@@ -1,3 +1,4 @@
+import type { StarterContent } from '../publishWire.ts';
 type Outcome = {
     code: number;
     data: Record<string, unknown>;
@@ -15,7 +16,8 @@ export type PublishingIo = {
 };
 export declare function login(io: PublishingIo): Promise<Outcome>;
 export declare function pull(io: PublishingIo, name: string | undefined, cwd: string, setupCode: string | undefined): Promise<Outcome>;
-export declare function publish(io: PublishingIo, root: string, isStarter: boolean, message: string | undefined): Promise<Outcome>;
+export declare function publish(io: PublishingIo, root: string, isStarter: boolean, message: string | undefined, starter: StarterContent | undefined): Promise<Outcome>;
+export declare function addLiveMedia(io: PublishingIo, root: string, form: FormData, again: string): Promise<Outcome>;
 export declare function versions(io: PublishingIo, root: string): Promise<Outcome>;
 export declare function restore(io: PublishingIo, root: string, number: string | undefined): Promise<Outcome>;
 export {};

package/dist/cli/publishing.js

@@ -3,7 +3,7 @@ import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, st
 import { homedir } from 'node:os';
 import { basename, dirname, extname, join, matchesGlob, relative } from 'node:path';
 import { z } from 'zod';
-import { DASHBOARD_URL, UPLOAD, appSummary, isPrivatePath, loginPoll, loginStarted, nameProblem, publishMessage, publishSummary, setupCodeExchanged, sourcePathProblem } from "../publishWire.js";
+import { DASHBOARD_URL, UPLOAD, appSummary, isPrivatePath, loginPoll, loginStarted, mediaRow, nameProblem, publishMessage, publishSummary, setupCodeExchanged, sourcePathProblem } from "../publishWire.js";
 import { appInfo } from "../appTitle.js";
 import { SESSION_COOKIE } from "../auth/user.js";
 import { PROJECT_FILE, readProjectFile } from "../vite/projectFile.js";
@@ -51,6 +51,9 @@ const STEP_WORDS = {
 function dashboard() {
     return (process.env['PATTERN_DASHBOARD_URL'] ?? DASHBOARD_URL).replace(/\/$/, '');
 }
+function sayHost(io) {
+    io.say(`  via ${new URL(dashboard()).host}`);
+}
 const credentials = z.record(z.string(), z.object({ cookie: z.string() }));
 const pendingLogin = z.object({
     dashboard: z.string(),
@@ -280,6 +283,7 @@ export async function pull(io, name, cwd, setupCode) {
             text: '✗ Which site? app pull acmeflower'
         };
     }
+    sayHost(io);
     const target = folderFor(name, cwd);
     if (target !== cwd && existsSync(target) && !isEmptyFolder(target)) {
         return {
@@ -403,7 +407,7 @@ function workerDirectory(dist) {
 function starterPackageJson(path, sdkVersion) {
     return readFileSync(path, 'utf8').replace(/"@trypattern\/sdk": "workspace:[^"]*"/, `"@trypattern/sdk": "${sdkVersion}"`);
 }
-function uploadForm(root, io, isStarter) {
+function uploadForm(root, io, isStarter, starter) {
     const dist = join(root, 'dist');
     const worker = workerDirectory(dist);
     if (worker === undefined)
@@ -431,6 +435,13 @@ function uploadForm(root, io, isStarter) {
         form.append(`${UPLOAD.migrations}${file}`, fileBlob(join(migrations, file)), file);
     }
     const sources = sourceFiles(root);
+    if (starter !== undefined) {
+        const left = starter.photos.find((photo) => !sources.includes(photo.path));
+        if (left !== undefined) {
+            throw new Error(`${left.path} is ignored by .gitignore, so it can't go with the starter`);
+        }
+        form.append(UPLOAD.starter, JSON.stringify(starter));
+    }
     if (isStarter && !sources.includes(STARTER_WORKSPACE)) {
         form.append(`${UPLOAD.source}${STARTER_WORKSPACE}`, new Blob([STARTER_BUILD_SETTINGS], { type: 'text/yaml' }), STARTER_WORKSPACE);
     }
@@ -478,18 +489,19 @@ async function followPublish(io, name, started) {
         text: `✗ Version ${publish.number} is still publishing after ${PUBLISH_WAIT_MS / 60_000} minutes\n  next  app versions shows how it ends`
     };
 }
-export async function publish(io, root, isStarter, message) {
+export async function publish(io, root, isStarter, message, starter) {
     try {
+        sayHost(io);
         const { name } = readProjectFile(root);
         const built = await io.build();
         if (built.code !== 0)
             return built;
         io.say('✓ Built');
-        const { form, sources } = uploadForm(root, io, isStarter);
+        const { form, sources } = uploadForm(root, io, isStarter, starter);
         const said = publishMessage(message ?? '');
         if (said !== null)
             form.append(UPLOAD.message, said);
-        io.say(`✓ Packed the build and ${sources} source files`);
+        io.say(`✓ Packed the build and ${sources} source files${starter === undefined ? '' : `, with ${starter.photos.length} starter photos`}`);
         const again = isStarter ? 'app publish --starter' : 'app publish';
         const result = await signedIn(io, again, async () => {
             if (isStarter) {
@@ -519,6 +531,22 @@ export async function publish(io, root, isStarter, message) {
         return failure(error);
     }
 }
+export async function addLiveMedia(io, root, form, again) {
+    try {
+        sayHost(io);
+        const { name } = readProjectFile(root);
+        const result = await signedIn(io, again, () => callJson(`/api/apps/${name}/media`, mediaRow, {
+            method: 'POST',
+            body: form
+        }));
+        if (isOutcome(result))
+            return result;
+        return { code: 0, data: { name, media: result }, text: '' };
+    }
+    catch (error) {
+        return failure(error);
+    }
+}
 export async function versions(io, root) {
     try {
         const { name } = readProjectFile(root);

package/dist/cli/starter.d.ts

@@ -0,0 +1,17 @@
+import type { StarterContent } from '../publishWire.ts';
+import type { PhotoFacts } from '../server/media.ts';
+import type { Seed, Tables } from '../table.ts';
+export declare const STARTER_ROWS = "starter/rows.ts";
+export declare const STARTER_PHOTOS = "starter/photos";
+export type StarterPhotoFile = PhotoFacts & {
+    id: string;
+    alt: string;
+    path: string;
+};
+export type LoadedStarter = {
+    photos: readonly StarterPhotoFile[];
+    rows: Seed<Tables>;
+};
+export declare function readStarter(root: string, tables: Tables): Promise<LoadedStarter | undefined>;
+export declare function withStarter(seed: Seed<Tables>, starter: LoadedStarter | undefined): Seed<Tables>;
+export declare function starterContentOf(tables: Tables, starter: LoadedStarter): StarterContent;