@trylight/app 0.1.9 → 0.2.1

package/dist/auth/plaza.js

@@ -0,0 +1,154 @@
+import { z } from "zod/v4";
+import { miiAuthConfig } from "./config.js";
+/**
+ * Check an email and password with the platform, and get back who the person is and
+ * the session the platform signed for them.
+ */
+export async function signInWithPlaza(email, password) {
+    const { plazaUrl, appId } = miiAuthConfig();
+    let response;
+    try {
+        response = await fetch(`${plazaUrl}/api/app-auth/sign-in`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ appId, email, password }),
+            cache: "no-store"
+        });
+    }
+    catch (cause) {
+        return {
+            ok: false,
+            failure: {
+                kind: "unavailable",
+                message: "Sign-in is unreachable right now. Try again in a moment.",
+                cause
+            }
+        };
+    }
+    if (response.ok) {
+        const body = await response.json();
+        const signedIn = asSignedIn(body);
+        if (signedIn !== null) {
+            return { ok: true, ...signedIn };
+        }
+        return {
+            ok: false,
+            failure: {
+                kind: "unavailable",
+                message: "Sign-in answered with something unexpected. Try again.",
+                cause: new Error(`Platform sign-in answered 200 without an identity and session: ${JSON.stringify(body)}`)
+            }
+        };
+    }
+    return {
+        ok: false,
+        failure: failureFor(response.status, await response.text())
+    };
+}
+/**
+ * Spend a code for the person behind it, or null if it is spent or stale.
+ *
+ * Throws when the platform itself is the problem — a 5xx or an unreadable answer — so
+ * that reaches the route's error reporting rather than looking like a stale
+ * code and sending the person round again.
+ */
+export async function redeemWithPlaza(code) {
+    const { plazaUrl, appId } = miiAuthConfig();
+    const response = await fetch(`${plazaUrl}/api/app-auth/redeem`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ appId, code }),
+        cache: "no-store"
+    });
+    if (response.status >= 500) {
+        throw new Error(`Platform redeem answered ${response.status}: ${await response.text()}`);
+    }
+    if (!response.ok) {
+        return null;
+    }
+    const body = await response.json();
+    const signedIn = asSignedIn(body);
+    if (signedIn === null) {
+        throw new Error(`Platform redeem answered 200 without an identity and session: ${JSON.stringify(body)}`);
+    }
+    return signedIn;
+}
+/**
+ * Whether the platform still stands behind a session: "ended" when the token is no
+ * longer good or the person has left the org. Throws when the platform cannot say, so
+ * an outage is reported rather than read as either answer.
+ */
+export async function checkPlazaSession(token) {
+    const { plazaUrl } = miiAuthConfig();
+    // Asked from inside a page load, so the platform that hangs must not hang the page.
+    const response = await fetch(`${plazaUrl}/api/app-chat/v1/session`, {
+        headers: { Authorization: `Bearer ${token}` },
+        cache: "no-store",
+        signal: AbortSignal.timeout(PLAZA_SESSION_TIMEOUT_MS)
+    });
+    if (response.ok)
+        return "valid";
+    if (response.status === 401 || response.status === 403)
+        return "ended";
+    throw new Error(`Platform session check answered ${response.status}: ${(await response.text()).slice(0, 300)}`);
+}
+/**
+ * Tell the platform a session is over, so the token stops working now rather than when
+ * it expires. Throws when the platform did not take it.
+ */
+export async function revokePlazaSession(token) {
+    const { plazaUrl } = miiAuthConfig();
+    const response = await fetch(`${plazaUrl}/api/app-chat/v1/session`, {
+        method: "DELETE",
+        headers: { Authorization: `Bearer ${token}` },
+        cache: "no-store",
+        signal: AbortSignal.timeout(PLAZA_SESSION_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+        throw new Error(`Platform session revoke answered ${response.status}: ${(await response.text()).slice(0, 300)}`);
+    }
+}
+const PLAZA_SESSION_TIMEOUT_MS = 5000;
+/** A sign-in or redeem answer: who the person is, and the session the platform signed. */
+const signedInBody = z.object({
+    miiId: z.string(),
+    orgId: z.string(),
+    name: z.string(),
+    email: z.string().nullable().catch(null),
+    avatarUrl: z.string().nullable().catch(null),
+    // A platform that does not say `isAgent` is one whose agents do not sign in
+    // to apps, and an app can be running ahead of the platform in front of it.
+    isAgent: z.boolean().catch(false),
+    session: z.object({ token: z.string(), expiresAt: z.string().pipe(z.coerce.date()) })
+});
+function asSignedIn(body) {
+    const read = signedInBody.safeParse(body);
+    if (!read.success)
+        return null;
+    const { session, ...identity } = read.data;
+    return { identity, session };
+}
+function failureFor(status, body) {
+    if (status === 401) {
+        return { kind: "credentials", message: "Wrong email or password." };
+    }
+    if (status === 403) {
+        return {
+            kind: "not_a_member",
+            // Said plainly: they have just proved they own the account, so this is
+            // not a secret from them, and it is the one thing they can act on.
+            message: "That account isn't set up for this app. Ask whoever runs it."
+        };
+    }
+    if (status === 429) {
+        return {
+            kind: "throttled",
+            message: "Too many wrong tries. Wait a minute and try again."
+        };
+    }
+    return {
+        kind: "unavailable",
+        message: "Sign-in isn't answering right now. Try again in a moment.",
+        cause: new Error(`Platform sign-in answered ${status}: ${body.slice(0, 300)}`)
+    };
+}

package/dist/auth/problems.d.ts

@@ -0,0 +1,4 @@
+export declare const SIGN_IN_PROBLEMS: Record<string, {
+    readonly title: string;
+    readonly body: string;
+}>;

package/dist/auth/problems.js

@@ -0,0 +1,36 @@
+// Why a sign-in did not happen, in words worth reading.
+//
+// The code travels in the URL and the words live here, so a failure never puts
+// an email, a password, or a message the platform wrote into someone's address bar or
+// their history. Each one says what to do next, because "try again" is only the
+// right advice for some of them.
+export const SIGN_IN_PROBLEMS = {
+    credentials: {
+        title: "Wrong email or password",
+        body: "Check both and try again. It's the same account you use to talk to your team's agents."
+    },
+    not_a_member: {
+        title: "That account can't open this app",
+        body: "The password was right, but the account isn't in this app's org. Ask whoever runs it to add you."
+    },
+    deactivated: {
+        title: "Your access here has been turned off",
+        body: "Ask whoever runs this app to turn it back on."
+    },
+    throttled: {
+        title: "Too many wrong tries",
+        body: "Wait a minute, then try again."
+    },
+    expired: {
+        title: "That took too long",
+        body: "The sign-in expired before it finished. Try again."
+    },
+    unavailable: {
+        title: "Sign-in isn't answering",
+        body: "This is our side, not yours. Try again in a moment."
+    },
+    missing: {
+        title: "Enter your email and password",
+        body: "Both are needed to sign in."
+    }
+};

package/dist/auth/users.d.ts

@@ -0,0 +1,8 @@
+import type { AuthContext } from "./context.js";
+import type { MiiIdentity } from "./plaza.js";
+export declare function upsertMemberFromIdentity(ctx: AuthContext, identity: MiiIdentity): Promise<{
+    id: string;
+    status: string;
+}>;
+/** Deactivate a user: their sessions stop working on the next request. */
+export declare function deactivateUser(ctx: AuthContext, userId: string): Promise<void>;

package/dist/auth/users.js

@@ -0,0 +1,25 @@
+// The user row behind a sign-in. Created the first time someone arrives,
+// refreshed on every visit from what the platform says now (name, email, avatar), and
+// keyed on the actor id — the one thing about a person that never changes.
+export async function upsertMemberFromIdentity(ctx, identity) {
+    const sql = await ctx.getSql();
+    const kind = identity.isAgent ? "agent" : "member";
+    const [user = null] = await sql `
+    insert into mii_auth_users (mii_id, email, name, avatar_url, kind, last_login_at)
+    values (${identity.miiId}, ${identity.email}, ${identity.name}, ${identity.avatarUrl}, ${kind}, now())
+    on conflict (mii_id) do update set
+      email = excluded.email,
+      name = excluded.name,
+      avatar_url = excluded.avatar_url,
+      last_login_at = now()
+      ${identity.isAgent ? sql `, kind = 'agent'` : sql ``}
+    returning id, status`;
+    if (user === null)
+        throw new Error("Upserting into mii_auth_users returned no row.");
+    return user;
+}
+/** Deactivate a user: their sessions stop working on the next request. */
+export async function deactivateUser(ctx, userId) {
+    const sql = await ctx.getSql();
+    await sql `update mii_auth_users set status = 'inactive' where id = ${userId}`;
+}

package/dist/brand.generated.d.ts

@@ -0,0 +1,2 @@
+/** The platform app's origins, current domain first. */
+export declare const APP_ORIGINS: readonly string[];

package/dist/brand.generated.js

@@ -0,0 +1,3 @@
+// Generated from config/brand.json by scripts/write-brand.ts. Do not edit.
+/** The platform app's origins, current domain first. */
+export const APP_ORIGINS = ["https://trylight.ai", "https://plaza.miis.run"];

package/dist/chat/paths.d.ts

@@ -0,0 +1,10 @@
+/** Where an app mounts its chat routes, and where the widget calls them. */
+export declare const CHAT_BASE_PATH = "/api/mii/chat";
+/**
+ * What the app's chat server can do beyond the first contract, listed on its
+ * answers. The platform serves the widget to apps on every runtime version, so the
+ * widget offers only what this app's server says it forwards.
+ */
+export declare const CHAT_FEATURES_HEADER = "X-Mii-Chat-Features";
+export declare const REACTIONS_FEATURE = "reactions";
+export declare const CREDITS_FEATURE = "credits";

package/dist/chat/paths.js

@@ -0,0 +1,10 @@
+/** Where an app mounts its chat routes, and where the widget calls them. */
+export const CHAT_BASE_PATH = "/api/mii/chat";
+/**
+ * What the app's chat server can do beyond the first contract, listed on its
+ * answers. The platform serves the widget to apps on every runtime version, so the
+ * widget offers only what this app's server says it forwards.
+ */
+export const CHAT_FEATURES_HEADER = "X-Mii-Chat-Features";
+export const REACTIONS_FEATURE = "reactions";
+export const CREDITS_FEATURE = "credits";

package/dist/chat/server.d.ts

@@ -0,0 +1,24 @@
+import type { MiiAuthCore } from "../auth/core.js";
+export type MiiChatHandlerOptions = {
+    /** Where to report failures that are ours. Defaults to console.error. */
+    readonly reportError?: (error: unknown, context: Record<string, string>) => void;
+};
+/** Why the platform stopped standing behind a session. */
+export type ChatRevokeReason = "token_rejected" | "not_a_member";
+export type ChatAuth = Pick<MiiAuthCore, "resolveSessionWithPlaza" | "SESSION_COOKIE"> & {
+    /**
+     * Let go of a session the platform has refused. An app whose session is the platform's own
+     * ends it whatever the reason; one that keeps its own session ends only the
+     * part the platform gave it, and only when signing in again would help.
+     */
+    revokeSession(token: string, reason?: ChatRevokeReason): Promise<void>;
+};
+export declare function createMiiChatHandler(auth: ChatAuth, { reportError }?: MiiChatHandlerOptions): (request: Request) => Promise<Response>;
+/**
+ * Whether the request came from this app's own pages. Browsers send
+ * `Sec-Fetch-Site` on every fetch; `Origin` covers the ones that predate it.
+ * A request with neither is not from a browser page, and a non-browser caller
+ * has no cookie to borrow.
+ */
+export declare function isSameOrigin(request: Request, url: URL): boolean;
+export declare function readCookie(header: string | null, name: string): string | null;

package/dist/chat/server.js

@@ -0,0 +1,161 @@
+// The server half of an org app's chat: the routes the widget calls, on the
+// app's own origin, forwarded to the platform as the signed-in person.
+//
+// Framework-free: a Web `Request` in, a `Response` out. The app mounts it once
+// on a catch-all route under CHAT_BASE_PATH:
+//
+//   // src/routes/api/mii/chat/$.ts (TanStack Start)
+//   const chat = createMiiChatHandler(auth);
+//   export const Route = createFileRoute("/api/mii/chat/$")({
+//     server: { handlers: { GET: ({ request }) => chat(request), POST: ({ request }) => chat(request) } }
+//   });
+//
+// The browser never holds a credential for the platform. It sends this app's own
+// session cookie; this server looks the session up and sends the platform the token
+// the platform signed when the person signed in. The platform checks that token and the
+// person's membership on every request.
+import { miiAuthConfig } from "../auth/config.js";
+import { CHAT_BASE_PATH, CHAT_FEATURES_HEADER, CREDITS_FEATURE, REACTIONS_FEATURE } from "./paths.js";
+// The platform's browser-facing chat routes all sit under this one prefix, and this
+// server forwards any path beneath it: a widget route the platform adds needs no
+// release of this package. The platform's server-only routes (session) are outside it,
+// and each route under it validates its own ids.
+const PLAZA_CHAT_PATH = "/api/app-chat/v1/chat";
+// Plain segments only: no dots, no percent-encoding, no empty segment. A path
+// that could climb out of the platform's prefix (`..`, `%2e%2e`, `%2f`, `//`) never
+// leaves this server.
+const FORWARDABLE_PATH = /^(\/[A-Za-z0-9_-]+)+$/;
+// What the thread's poll and its pages may carry through. Everything else in
+// the query string is dropped rather than forwarded.
+const FORWARDED_QUERY = ["after", "afterId", "limit", "before", "beforeId"];
+export function createMiiChatHandler(auth, { reportError = (error, context) => console.error("mii-chat error", context, error) } = {}) {
+    return async (request) => {
+        const url = new URL(request.url);
+        if (!url.pathname.startsWith(`${CHAT_BASE_PATH}/`)) {
+            return refuse(404, "not_found", "There's no chat here.");
+        }
+        const path = url.pathname.slice(CHAT_BASE_PATH.length);
+        const method = request.method;
+        if ((method !== "GET" && method !== "POST") || !FORWARDABLE_PATH.test(path)) {
+            return refuse(404, "not_found", "There's no chat here.");
+        }
+        // Every org app shares one site with every other (*.<domain>), so a page
+        // on another org's app can send this app's cookie along. Only this app's
+        // own pages may use its chat.
+        if (!isSameOrigin(request, url)) {
+            return refuse(403, "cross_site", "Chat is only available from this app's own pages.");
+        }
+        const token = readCookie(request.headers.get("cookie"), auth.SESSION_COOKIE);
+        if (token === null) {
+            return refuse(401, "not_signed_in", "Sign in to chat with your agents.");
+        }
+        const session = await auth.resolveSessionWithPlaza(token);
+        if (session === null) {
+            // Signed in here, holding nothing to act with. Its own answer, so the
+            // widget can say why rather than not being there.
+            return refuse(401, "sign_in_again", "Sign out and back in to use it here.");
+        }
+        const { plazaUrl } = miiAuthConfig();
+        const target = new URL(`${plazaUrl}${PLAZA_CHAT_PATH}${path}`);
+        for (const key of FORWARDED_QUERY) {
+            const value = url.searchParams.get(key);
+            if (value !== null)
+                target.searchParams.set(key, value);
+        }
+        let answer;
+        try {
+            // `duplex` is how fetch takes a streamed body; DOM's RequestInit predates it.
+            const init = {
+                method,
+                // Only these: never the browser's cookie or its own Authorization.
+                // The platform's chat routes take JSON; files go straight to storage.
+                headers: {
+                    Authorization: `Bearer ${session.plazaToken}`,
+                    ...(method === "POST" ? { "Content-Type": "application/json" } : {})
+                },
+                body: method === "POST" ? request.body : undefined,
+                duplex: "half",
+                cache: "no-store",
+                // An agent with a photo answers with a redirect to it: the browser
+                // follows that itself, rather than this server fetching the photo.
+                redirect: "manual"
+            };
+            answer = await fetch(target, init);
+        }
+        catch (error) {
+            reportError(error, { where: "mii-chat", step: "forward" });
+            return refuse(502, "unavailable", "Couldn't reach the chat. Try again in a moment.");
+        }
+        // The platform no longer stands behind this session: the token is no good, or the
+        // person is no longer in the org. Which one matters to the app — one is
+        // fixed by signing in again and the other is not — so it is passed on.
+        if (answer.status === 401 || answer.status === 403) {
+            await auth.revokeSession(token, answer.status === 403 ? "not_a_member" : "token_rejected");
+        }
+        if (answer.status >= 500) {
+            reportError(new Error(`Platform chat answered ${answer.status}: ${(await answer.clone().text()).slice(0, 300)}`), { where: "mii-chat", step: "plaza" });
+        }
+        // An avatar may be cached for the person; chat data never is.
+        const cacheControl = answer.headers.get("cache-control");
+        const headers = new Headers({
+            "Cache-Control": cacheControl !== null && cacheControl.startsWith("private") ? cacheControl : "no-store",
+            [CHAT_FEATURES_HEADER]: [REACTIONS_FEATURE, CREDITS_FEATURE].join(",")
+        });
+        const contentType = answer.headers.get("content-type");
+        if (contentType !== null)
+            headers.set("Content-Type", contentType);
+        const location = answer.headers.get("location");
+        if (answer.status >= 300 && answer.status < 400 && location !== null) {
+            headers.set("Location", location);
+        }
+        const policy = answer.headers.get("content-security-policy");
+        if (policy !== null)
+            headers.set("Content-Security-Policy", policy);
+        return new Response(answer.body, { status: answer.status, headers });
+    };
+}
+/**
+ * Whether the request came from this app's own pages. Browsers send
+ * `Sec-Fetch-Site` on every fetch; `Origin` covers the ones that predate it.
+ * A request with neither is not from a browser page, and a non-browser caller
+ * has no cookie to borrow.
+ */
+export function isSameOrigin(request, url) {
+    const site = request.headers.get("sec-fetch-site");
+    if (site !== null && site !== "same-origin") {
+        return false;
+    }
+    const origin = request.headers.get("origin");
+    return origin === null || origin === url.origin || servedAt(request).includes(new URL(origin).host);
+}
+/**
+ * Every address this request reached the app on. Behind proxies the request
+ * URL can carry an internal host; each hop appends the host it was asked for
+ * to X-Forwarded-Host, and a hop may rewrite Origin to its own address.
+ */
+function servedAt(request) {
+    return [request.headers.get("x-forwarded-host"), request.headers.get("host")]
+        .filter((value) => value !== null)
+        .flatMap((value) => value.split(",").map((host) => host.trim()));
+}
+export function readCookie(header, name) {
+    if (header === null)
+        return null;
+    for (const part of header.split(";")) {
+        const index = part.indexOf("=");
+        if (index === -1)
+            continue;
+        if (part.slice(0, index).trim() === name) {
+            const value = part.slice(index + 1).trim();
+            return value === "" ? null : value;
+        }
+    }
+    return null;
+}
+// The platform's error shape: the sentence a person reads, and the reason as a code.
+function refuse(status, code, error) {
+    return new Response(JSON.stringify({ error, code }), {
+        status,
+        headers: { "Content-Type": "application/json", "Cache-Control": "no-store" }
+    });
+}

package/dist/client.d.ts

@@ -1,15 +1,15 @@
 import { type QueryKey } from "@tanstack/react-query";
-import type { Contracts } from "@shubh90/app-runtime/invoke/server";
+import type { Contracts } from "./invoke/server.js";
 import { EntityError, type ListOptions, type NewRow, type Patch, type Row } from "./entities.js";
 import type { Entity } from "./schema.js";
 export { EntityError, LIST_LIMIT, type ListOptions, type NewRow, type Sort, type Patch, type Row, type Where } from "./entities.js";
 export type { FieldSource, FieldSources } from "./schema.js";
 export { siteOf } from "./schema.js";
 export { imageSrc } from "./images.js";
-export { InvocationError, type InvocationStatus } from "@shubh90/app-runtime/invoke";
+export { InvocationError, type InvocationStatus } from "./invoke/index.js";
 export declare function createApp<C extends Contracts = Record<never, never>>(): {
     table: typeof tableClient;
-    contracts: import("@shubh90/app-runtime/invoke").Invoker<C>;
+    contracts: import("./invoke/index.js").Invoker<C>;
 };
 /** Rows one page of `useInfiniteList` asks for; scrolling near the end asks for the next. */
 export declare const PAGE_SIZE = 100;

package/dist/client.js

@@ -7,14 +7,14 @@
 // shows at once and never snaps back. `app.contracts` asks the org's agents.
 import { hashKey, keepPreviousData, skipToken, useInfiniteQuery, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { useEffect, useMemo, useState } from "react";
-import { createInvoker } from "@shubh90/app-runtime/invoke";
+import { createInvoker } from "./invoke/index.js";
 import { getTableColumns, getTableName } from "drizzle-orm";
 import { z } from "zod/v4";
 import { ENTITIES_PATH, EntityError, LIST_LIMIT } from "./entities.js";
 export { EntityError, LIST_LIMIT } from "./entities.js";
 export { siteOf } from "./schema.js";
 export { imageSrc } from "./images.js";
-export { InvocationError } from "@shubh90/app-runtime/invoke";
+export { InvocationError } from "./invoke/index.js";
 export function createApp() {
     return { table: tableClient, contracts: createInvoker() };
 }

package/dist/db/cli.js

@@ -1,6 +1,5 @@
 // `light-db sync`, `light-db migrate`, `light-db check`: the
-// app's `pnpm db:*` scripts; `light-db baseline` moves an older app's tables
-// under db/schema, once. Run from the app's root.
+// app's `pnpm db:*` scripts. Run from the app's root.
 import { existsSync } from "node:fs";
 import { request } from "node:http";
 import { userInfo } from "node:os";
@@ -11,7 +10,6 @@ import { migrate } from "drizzle-orm/postgres-js/migrator";
 import postgres from "postgres";
 import { z } from "zod/v4";
 import { archiveNotices, entityTables, prepareAudit, trackTables } from "./audit.js";
-import { BaselineRefused, baseline as writeBaseline } from "./baseline.js";
 import { MIGRATIONS_DIR, SCHEMA_ENTRY, plan, unwriteMigration, writeMigration } from "./migrations.js";
 import { env } from "../server/env.js";
 /**
@@ -127,42 +125,7 @@ async function migrateThroughPlatform() {
     process.stdout.write(reply.output);
     return reply.code;
 }
-/** Writes db/schema and a first migration from the live tables of an app made before db/schema. */
-async function baseline() {
-    const { databaseUrl } = env();
-    if (databaseUrl === undefined)
-        throw new Error("DATABASE_URL is not set: baseline reads the app's database.");
-    let written;
-    try {
-        written = await writeBaseline(root, databaseUrl);
-    }
-    catch (error) {
-        if (!(error instanceof BaselineRefused))
-            throw error;
-        console.error(error.message);
-        return 1;
-    }
-    console.log(`Wrote db/schema from the database, and ${MIGRATIONS_DIR}/0000_baseline.sql recording its tables as they are:`);
-    for (const table of written.tables) {
-        const lacks = table.lacks.length > 0 ? ` (lacks ${table.lacks.join(", ")}; the first sync adds them)` : "";
-        console.log(`  db/schema/${table.name}.ts${lacks}`);
-    }
-    console.log('Every entity is { read: "door", write: "door" }; make one `write: "agents"` if only agents fill it.');
-    if (written.plain.length > 0) {
-        console.log("Plain tables (no sync changes them; app.table can't serve them):");
-        for (const table of written.plain)
-            console.log(`  db/schema/${table.name}.ts: ${table.why}`);
-    }
-    if (written.skipped.length > 0)
-        console.log(`Skipped, the platform's own tables: ${written.skipped.join(", ")}.`);
-    if (written.leftOut.length > 0)
-        console.log(`Left in the database, not in db/schema: ${written.leftOut.join(", ")}.`);
-    console.log(written.pending.length === 0
-        ? "`pnpm db:sync` has nothing to change."
-        : `\`pnpm db:sync\` will only add this; nothing already there changes:\n${written.pending.join("\n")}`);
-    return 0;
-}
 // Last, so every const above is initialized before a command reads it.
-const commands = { sync, migrate: applyMigrations, check, baseline };
-const usage = z.enum(["sync", "migrate", "check", "baseline"], { error: "Usage: light-db sync | migrate | check | baseline" });
+const commands = { sync, migrate: applyMigrations, check };
+const usage = z.enum(["sync", "migrate", "check"], { error: "Usage: light-db sync | migrate | check" });
 process.exit(await commands[usage.parse(command)]());

package/dist/db/migrations.d.ts

@@ -10,7 +10,7 @@ export type Plan = {
     snapshot: Snapshot;
 };
 /** The parts of a drizzle-kit snapshot a removal touches; the rest passes through. */
-export declare const snapshotSchema: z.ZodObject<{
+declare const snapshotSchema: z.ZodObject<{
     id: z.ZodString;
     tables: z.ZodRecord<z.ZodString, z.ZodObject<{
         columns: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -37,7 +37,6 @@ export type Snapshot = z.infer<typeof snapshotSchema>;
  * after the columns that used them have changed.
  */
 export declare function plan(root: string, schema: Record<string, unknown>): Promise<Plan>;
-export declare const EMPTY_SNAPSHOT: Snapshot;
 /**
  * Writes the plan as the next migration, in drizzle-kit's own layout (the
  * SQL, its snapshot, the journal entry), so drizzle's migrator applies it.
@@ -45,3 +44,4 @@ export declare const EMPTY_SNAPSHOT: Snapshot;
 export declare function writeMigration(root: string, planned: Plan, name?: string): string;
 /** Takes back the newest migration, one that didn't apply, so the schema's change is pending again. */
 export declare function unwriteMigration(root: string, tag: string): void;
+export {};

package/dist/db/migrations.js

@@ -12,7 +12,7 @@ export const SCHEMA_ENTRY = "db/schema/index.ts";
 export const MIGRATIONS_DIR = "db/migrations";
 const entries = z.record(z.string(), z.unknown());
 /** The parts of a drizzle-kit snapshot a removal touches; the rest passes through. */
-export const snapshotSchema = z.looseObject({
+const snapshotSchema = z.looseObject({
     id: z.string(),
     tables: z.record(z.string(), z.looseObject({
         columns: entries,
@@ -102,7 +102,7 @@ const journalSchema = z.object({
         breakpoints: z.boolean()
     }))
 });
-export const EMPTY_SNAPSHOT = {
+const EMPTY_SNAPSHOT = {
     version: "7",
     dialect: "postgresql",
     id: "00000000-0000-0000-0000-000000000000",

package/dist/invoke/contracts.d.ts

@@ -0,0 +1,28 @@
+import type { z } from "zod/v4";
+type ObjectSchema = z.ZodType<Record<string, unknown>, Record<string, unknown>>;
+export type Contract = {
+    /** The id `mii contract create` printed. */
+    readonly id: string;
+    readonly input: ObjectSchema;
+    readonly output: ObjectSchema;
+};
+export type Contracts = Readonly<Record<string, Contract>>;
+export type ContractInput<C extends Contracts, K extends keyof C> = z.input<C[K]["input"]>;
+export type ContractOutput<C extends Contracts, K extends keyof C> = z.output<C[K]["output"]>;
+export type InvocationState = "pending" | "succeeded" | "failed";
+/** What the app's invoke routes answer with; `Output` is a contract's, once the app's schema has parsed it. */
+export type Invocation<Output = Record<string, unknown>> = {
+    readonly id: string;
+    /** The input the run was started with: the JSON of the app's schema's parse at the start. */
+    readonly input: Record<string, unknown>;
+    readonly lastError: string | null;
+    readonly createdAt: string;
+    readonly finishedAt: string | null;
+} & ({
+    readonly state: "pending" | "failed";
+    readonly result: null;
+} | {
+    readonly state: "succeeded";
+    readonly result: Output;
+});
+export {};

package/dist/invoke/contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/invoke/error.d.ts

@@ -0,0 +1,11 @@
+import { RequestError } from "../request-error.js";
+/**
+ * Why an invocation did not produce a result. `code` is the server's
+ * (`not_signed_in`, `invalid_input`, `unknown_contract`, `result_mismatch`, …),
+ * or `failed` when the agents could not produce a result matching the schema.
+ * `status` is 0 when no HTTP refusal is behind it: `failed`, or no answer at all.
+ */
+export declare class InvocationError extends RequestError {
+}
+/** A run the agents closed without a result that matches its schema. */
+export declare function failedRun(lastError: string | null): InvocationError;

package/dist/invoke/error.js

@@ -0,0 +1,13 @@
+import { RequestError } from "../request-error.js";
+/**
+ * Why an invocation did not produce a result. `code` is the server's
+ * (`not_signed_in`, `invalid_input`, `unknown_contract`, `result_mismatch`, …),
+ * or `failed` when the agents could not produce a result matching the schema.
+ * `status` is 0 when no HTTP refusal is behind it: `failed`, or no answer at all.
+ */
+export class InvocationError extends RequestError {
+}
+/** A run the agents closed without a result that matches its schema. */
+export function failedRun(lastError) {
+    return new InvocationError(0, "failed", `The agents could not produce a valid result.${lastError === null ? "" : `\n${lastError}`}`);
+}