@gonvex/cli 0.1.32 → 0.3.1

package/dist/index.js

@@ -8,6 +8,7 @@ import { createInterface } from "node:readline/promises";
 import { dirname, join, relative, resolve } from "node:path";
 import { Writable } from "node:stream";
 import { fileURLToPath } from "node:url";
+import { buildModuleArtifact, detectProjectLanguage, moduleManifestFunctions, moduleSourceFiles, isModuleSchema, } from "./module-artifact.js";
 const defaultRuntimeURL = "http://localhost:8080";
 const runtimeSyncRetryMs = 5000;
 const runtimeStateCheckMs = 2500;
@@ -440,10 +441,14 @@ async function runCodegen(argv) {
     });
     const backendDir = join(projectRoot, "gonvex");
     await mkdir(backendDir, { recursive: true });
-    const files = await goFiles(backendDir);
-    const manifest = await buildManifest(projectRoot, files, settings.projectID);
+    const sources = await collectBackendSources(projectRoot);
+    const manifest = await buildManifest(projectRoot, sources, settings.projectID);
     await writeBindings(projectRoot, manifest);
-    console.log(`[gonvex] generated ${Object.keys(manifest.functions).length} function binding(s) without runtime sync`);
+    console.log(`[gonvex] generated ${Object.keys(manifest.functions).length} TypeScript function binding(s)`);
+    if (manifest.module) {
+        const fileCount = Object.keys(manifest.module.files).length;
+        console.log(`[gonvex] built ${manifest.module.language} module artifact ${manifest.module.hash.slice(0, 12)} from ${fileCount} file(s)`);
+    }
 }
 async function runEnv(argv) {
     const parsedArgs = parseEnvCommandArgs(argv);
@@ -530,7 +535,7 @@ async function runEnv(argv) {
     throw new Error(`unknown env command ${action}`);
 }
 export async function runAuth(argv) {
-    const optionsWithValues = ["--project", "--runtime-url", "--project-id", "--key", "--origin", "--callback-path", "--signup-mode", "--tenant", "--email", "--owner", "--role", "--user"];
+    const optionsWithValues = ["--project", "--runtime-url", "--project-id", "--key", "--origin", "--callback-path", "--signup-mode", "--tenant", "--email", "--owner", "--role", "--member", "--account"];
     const positional = positionalArgs(argv, optionsWithValues);
     const action = positional[0];
     if (!action || action === "help") {
@@ -655,20 +660,20 @@ export async function runAuth(argv) {
             throw new Error("Google auth production readiness check failed");
         return;
     }
-    if (action === "users" || action === "accounts") {
-        const usersEndpoint = `${settings.runtimeURL}/dev/projects/${encodeURIComponent(settings.projectID)}/auth/users`;
-        const payload = await runtimeJSON(await fetch(usersEndpoint, { headers: projectAuthHeaders(settings) }));
-        const users = payload.users ?? [];
+    if (action === "accounts") {
+        const accountsEndpoint = `${settings.runtimeURL}/dev/projects/${encodeURIComponent(settings.projectID)}/auth/accounts`;
+        const payload = await runtimeJSON(await fetch(accountsEndpoint, { headers: projectAuthHeaders(settings) }));
+        const accounts = payload.accounts ?? [];
         if (argv.includes("--json")) {
-            console.log(JSON.stringify(users, null, 2));
+            console.log(JSON.stringify(accounts, null, 2));
             return;
         }
-        if (users.length === 0) {
+        if (accounts.length === 0) {
             console.log(`[gonvex] no app accounts for ${settings.projectID}`);
             return;
         }
-        for (const user of users) {
-            console.log(`${user.id}\t${user.email ?? ""}\t${user.name ?? ""}\t${user.provider}`);
+        for (const account of accounts) {
+            console.log(`${account.id}\t${account.email ?? ""}\t${account.name ?? ""}\t${account.provider}`);
         }
         return;
     }
@@ -711,7 +716,7 @@ export async function runAuth(argv) {
                 return;
             }
             for (const member of payload.members ?? [])
-                console.log(`${member.userId}\t${member.email}\t${member.role}\t${member.name}`);
+                console.log(`${member.memberId}\t${member.email}\t${member.role}\t${member.name}`);
             for (const invitation of payload.invitations ?? [])
                 console.log(`invited\t${invitation.email}\t${invitation.role}\t${invitation.expiresAt ?? ""}`);
             return;
@@ -729,41 +734,41 @@ export async function runAuth(argv) {
             return;
         }
         if (operation === "remove" || operation === "rm") {
-            const user = valueFor(argv, "--user");
+            const member = valueFor(argv, "--member");
             const email = valueFor(argv, "--email");
-            if (!user && !email)
-                throw new Error("--user is required to remove a member, or --email to revoke an invitation");
-            const target = user ? `user=${encodeURIComponent(user)}` : `email=${encodeURIComponent(email)}`;
+            if (!member && !email)
+                throw new Error("--member is required to remove a member, or --email to revoke an invitation");
+            const target = member ? `member=${encodeURIComponent(member)}` : `email=${encodeURIComponent(email)}`;
             await runtimeJSON(await fetch(`${membershipEndpoint}&${target}`, {
                 method: "DELETE", headers: projectAuthHeaders(settings),
             }));
-            console.log(user
-                ? `[gonvex] removed ${user} from tenant ${tenant}`
+            console.log(member
+                ? `[gonvex] removed ${member} from tenant ${tenant}`
                 : `[gonvex] revoked the invitation for ${email} from tenant ${tenant}`);
             return;
         }
         throw new Error(`unknown auth memberships command ${operation}`);
     }
-    if (action === "user") {
+    if (action === "account") {
         const operation = positional[1];
-        const user = valueFor(argv, "--user") ?? positional[2];
-        if (!operation || !user)
-            throw new Error("usage: gonvex auth user <disable|enable|delete> <user-id>");
-        const userEndpoint = `${settings.runtimeURL}/dev/projects/${encodeURIComponent(settings.projectID)}/auth/users/${encodeURIComponent(user)}`;
+        const account = valueFor(argv, "--account") ?? positional[2];
+        if (!operation || !account)
+            throw new Error("usage: gonvex auth account <disable|enable|delete> <account-id>");
+        const accountEndpoint = `${settings.runtimeURL}/dev/projects/${encodeURIComponent(settings.projectID)}/auth/accounts/${encodeURIComponent(account)}`;
         if (operation === "disable" || operation === "enable") {
-            await runtimeJSON(await fetch(userEndpoint, {
+            await runtimeJSON(await fetch(accountEndpoint, {
                 method: "PATCH", headers: { ...projectAuthHeaders(settings), "content-type": "application/json" },
                 body: JSON.stringify({ disabled: operation === "disable" }),
             }));
-            console.log(`[gonvex] ${operation}d app account ${user}`);
+            console.log(`[gonvex] ${operation}d app account ${account}`);
             return;
         }
         if (operation === "delete" || operation === "remove") {
-            await runtimeJSON(await fetch(userEndpoint, { method: "DELETE", headers: projectAuthHeaders(settings) }));
-            console.log(`[gonvex] deleted app account ${user}`);
+            await runtimeJSON(await fetch(accountEndpoint, { method: "DELETE", headers: projectAuthHeaders(settings) }));
+            console.log(`[gonvex] deleted app account ${account}`);
             return;
         }
-        throw new Error(`unknown auth user command ${operation}`);
+        throw new Error(`unknown auth account command ${operation}`);
     }
     printAuthHelp();
     throw new Error(`unknown auth command ${action}`);
@@ -867,8 +872,8 @@ async function wireViteReactGoogleAuth(root) {
     if (main.includes('from "../gonvex/auth"') && app.includes("GoogleSignInButton"))
         return true;
     const providerImport = 'import { GonvexProvider } from "../gonvex/_generated/react";';
-    const reactImport = 'import { useMutation, useQuery } from "../gonvex/_generated/react";';
-    const appStart = 'export default function App(props: { runtimeURL: string }) {\n  const messages = useQuery<Message[]>(api.messages.list, {}) ?? [];';
+    const reactImport = 'import { useLiveQuery, useReducer } from "../gonvex/_generated/react";';
+    const appStart = 'export default function App(props: { runtimeURL: string }) {\n  const messages = useLiveQuery<Message[]>(api.messages.list, {}) ?? [];';
     if (!main.includes(providerImport) || !main.includes("<GonvexProvider client={gonvex}>") || !app.includes(reactImport) || !app.includes(appStart)) {
         return false;
     }
@@ -889,9 +894,9 @@ async function wireViteReactGoogleAuth(root) {
         "",
         "function AuthenticatedApp(props: { runtimeURL: string }) {",
         "  const auth = useGonvexAuth();",
-        '  const messages = useQuery<Message[]>(api.messages.list, {}) ?? [];',
+        '  const messages = useLiveQuery<Message[]>(api.messages.list, {}) ?? [];',
     ].join("\n"))
-        .replace('<div className="status">Connected to {props.runtimeURL}</div>', '<div className="status"><span>Connected to {props.runtimeURL} as {auth.user?.email}</span><GoogleSignInButton /></div>');
+        .replace('<div className="status">Connected to {props.runtimeURL}</div>', '<div className="status"><span>Connected to {props.runtimeURL} as {auth.account?.email}</span><GoogleSignInButton /></div>');
     await writeFile(mainPath, main);
     await writeFile(appPath, app);
     return true;
@@ -905,10 +910,17 @@ async function watchProject(root, settings, once, signal, initialState) {
     let lastSyncSucceeded = initialState?.lastSyncSucceeded ?? false;
     let lastRuntimeCheck = initialState?.lastRuntimeCheck ?? 0;
     while (!signal?.aborted) {
-        const files = await goFiles(backendDir);
+        const sources = await collectBackendSources(root);
         // Watch migrations too: editing or adding one must trigger a re-sync,
-        // otherwise a new migration sits unapplied until an unrelated .go edit.
-        const fingerprint = await filesFingerprint([...files, ...await migrationFiles(join(root, "migrations"))]);
+        // otherwise a new migration sits unapplied until an unrelated module edit.
+        // gonvex.json selects the TypeScript entrypoint and bundle destination. It
+        // belongs in the fingerprint, while gonvex/_build is excluded from source
+        // collection so writing the generated ESM cannot trigger a rebuild loop.
+        const configPath = join(root, "gonvex.json");
+        const fingerprintFiles = [...sources.moduleFiles, ...await migrationFiles(join(root, "migrations"))];
+        if (existsSync(configPath))
+            fingerprintFiles.push(configPath);
+        const fingerprint = await filesFingerprint(fingerprintFiles);
         const now = Date.now();
         const shouldBuild = fingerprint !== lastFingerprint;
         const shouldRetryRuntimeSync = !once && !lastSyncSucceeded && lastManifest !== null && now - lastSyncAttempt > runtimeSyncRetryMs;
@@ -917,7 +929,7 @@ async function watchProject(root, settings, once, signal, initialState) {
             lastFingerprint = fingerprint;
             let manifest;
             if (shouldBuild) {
-                manifest = await buildManifest(root, files, settings.projectID);
+                manifest = await buildManifest(root, sources, settings.projectID);
             }
             else {
                 manifest = lastManifest;
@@ -931,7 +943,12 @@ async function watchProject(root, settings, once, signal, initialState) {
             }
             lastSyncAttempt = now;
             try {
-                await syncRuntime(settings, manifest);
+                const observedSchema = await syncRuntime(settings, manifest);
+                if (observedSchema) {
+                    manifest.schema = observedSchema;
+                    lastManifest = manifest;
+                    await writeBindings(root, manifest);
+                }
                 lastSyncSucceeded = true;
                 lastRuntimeCheck = now;
                 console.log(`[gonvex] synced project ${settings.projectID || "(key-inferred)"} to ${settings.runtimeURL}`);
@@ -940,7 +957,7 @@ async function watchProject(root, settings, once, signal, initialState) {
                 lastSyncSucceeded = false;
                 const detail = error instanceof Error ? error.message : String(error);
                 const valkeyHint = isLocalRuntimeURL(settings.runtimeURL)
-                    ? " Local runtimes require a reachable VALKEY_URL (or REDIS_URL), for example VALKEY_URL=redis://127.0.0.1:6380/0."
+                    ? " Local runtimes require a reachable VALKEY_URL, for example VALKEY_URL=redis://127.0.0.1:6380/0."
                     : "";
                 console.error(`[gonvex] runtime sync failed: ${detail}.${valkeyHint}`);
             }
@@ -954,7 +971,12 @@ async function watchProject(root, settings, once, signal, initialState) {
                 const inSync = await runtimeHasManifest(settings, manifest);
                 if (!inSync) {
                     lastSyncAttempt = now;
-                    await syncRuntime(settings, manifest);
+                    const observedSchema = await syncRuntime(settings, manifest);
+                    if (observedSchema) {
+                        manifest.schema = observedSchema;
+                        lastManifest = manifest;
+                        await writeBindings(root, manifest);
+                    }
                     lastSyncSucceeded = true;
                     console.log(`[gonvex] runtime state was missing; re-synced project ${settings.projectID || "(key-inferred)"}`);
                 }
@@ -970,415 +992,56 @@ async function watchProject(root, settings, once, signal, initialState) {
     }
     return { lastFingerprint, lastManifest, lastSyncAttempt, lastSyncSucceeded, lastRuntimeCheck };
 }
-async function buildManifest(root, files, projectID) {
-    const functions = {};
-    const schema = emptySchemaDefinition();
-    let packageName = "app";
-    for (const file of files) {
-        Object.assign(functions, await parseRegistrations(root, file));
-        mergeSchemaDefinition(schema, await parseSchema(file));
-        if (packageName === "app") {
-            packageName = await detectPackageName(file);
-        }
-    }
-    const bundle = await buildSourceBundle(root, files, projectID, packageName);
+// Backend sources are collected once per build so the fingerprint, the
+// manifest, and the shipped artifact all agree on the same file set.
+async function collectBackendSources(root) {
+    const backendDir = join(root, "gonvex");
+    const config = await loadConfig(root);
+    const module = await moduleSourceFiles(backendDir);
+    await detectProjectLanguage(backendDir, config.language);
     return {
-        project: projectID,
-        generatedAt: new Date().toISOString(),
-        functions,
-        schema,
-        bundle,
+        moduleFiles: module,
+        config,
     };
 }
-async function buildSourceBundle(root, files, projectID, packageName) {
-    const backendDir = join(root, "gonvex");
-    const encodedFiles = {};
-    for (const file of files) {
-        const source = await readFile(file);
-        const rel = relative(backendDir, file).replace(/\\/g, "/");
-        encodedFiles[`app/${rel}`] = Buffer.from(source).toString("base64");
-    }
-    // Versioned SQL migrations ship in the bundle under migrations/, which is
-    // where the runtime looks for them. Without this the runtime sees no
-    // migrations at all and silently applies only the declarative schema.
-    for (const file of await migrationFiles(join(root, "migrations"))) {
-        const source = await readFile(file);
-        const rel = relative(join(root, "migrations"), file).replace(/\\/g, "/");
-        encodedFiles[`migrations/${rel}`] = Buffer.from(source).toString("base64");
-    }
-    const hash = createHash("sha256");
-    for (const path of Object.keys(encodedFiles).sort()) {
-        hash.update(`${path}:${encodedFiles[path]};`);
-    }
+async function buildManifest(root, sources, projectID) {
+    const module = await buildModuleArtifact({
+        root,
+        backendDir: join(root, "gonvex"),
+        files: sources.moduleFiles,
+        migrations: await migrationFiles(join(root, "migrations")),
+        entrypoint: sources.config.module?.entrypoint,
+        bundle: sources.config.module?.bundle,
+    });
     return {
-        hash: hash.digest("hex"),
-        modulePath: `gonvexapp/${sanitizeProjectID(projectID)}`,
-        packageName,
-        files: encodedFiles,
+        project: projectID,
+        generatedAt: new Date().toISOString(),
+        functions: moduleManifestFunctions(module),
+        schema: emptySchemaDefinition(),
+        module,
+        ...(Object.keys(module.visibility).length > 0 ? { visibility: module.visibility } : {}),
     };
 }
-async function detectPackageName(file) {
-    const source = await readFile(file, "utf8");
-    const match = source.match(/^package\s+([A-Za-z_][A-Za-z0-9_]*)/m);
-    return match?.[1] ?? "app";
-}
-function sanitizeProjectID(projectID) {
-    const trimmed = projectID.trim();
-    if (!trimmed)
-        return "project";
-    return trimmed.replace(/[^a-zA-Z0-9._-]+/g, "-");
-}
-async function parseRegistrations(root, file) {
-    const source = await readFile(file, "utf8");
-    const pattern = /app\.(Query|Mutation|Action|HTTP|PublicHTTP|InternalMutation|LiveGrid|Sync)\(\s*"([^"]+)"\s*,\s*([A-Za-z_][A-Za-z0-9_]*)/g;
-    const entries = {};
-    for (const match of source.matchAll(pattern)) {
-        const entry = {
-            kind: functionKind(match[1]),
-            handler: match[3],
-            file: relative(root, file),
-        };
-        const openParen = source.indexOf("(", match.index);
-        const closeParen = findClosingParen(source, openParen);
-        if (openParen >= 0 && closeParen > openParen) {
-            const dependencies = parseFunctionDependencies(source.slice(openParen + 1, closeParen));
-            if (Object.keys(dependencies).length > 0)
-                entry.dependencies = dependencies;
-            if (match[1] === "Sync") {
-                entry.sync = parseSyncDefinition(source.slice(openParen + 1, closeParen));
-            }
-        }
-        entries[match[2]] = entry;
-    }
-    return entries;
-}
-function parseSyncDefinition(callBody) {
-    const match = /(?:gonvex\.)?SyncTable\s*\(/.exec(callBody);
-    if (!match)
-        return undefined;
-    const openParen = callBody.indexOf("(", match.index);
-    const closeParen = findClosingParen(callBody, openParen);
-    if (closeParen < 0)
-        return undefined;
-    const table = stringArgs(callBody.slice(openParen + 1, closeParen))[0];
-    if (!table)
-        return undefined;
-    const definition = { table, key: "id", columns: [], mode: "eager" };
-    let cursor = closeParen + 1;
-    while (cursor < callBody.length) {
-        const chain = chainedGoMethod(callBody, cursor, "Key|Columns|EqualArg|ExcludeWhenSet|VisibilityDependsOn|OrderBy|Eager|Progressive|Budget");
-        if (!chain)
-            break;
-        const chainOpen = chain.openParen;
-        const chainClose = findClosingParen(callBody, chainOpen);
-        if (chainClose < 0)
-            break;
-        const method = chain.method;
-        const body = callBody.slice(chainOpen + 1, chainClose);
-        const values = stringArgs(body);
-        if (method === "Key" && values[0])
-            definition.key = values[0];
-        if (method === "Columns")
-            definition.columns = values;
-        if (method === "EqualArg" && values[0]) {
-            (definition.equalFilters ??= {})[values[0]] = values[1] ?? values[0];
-        }
-        if (method === "ExcludeWhenSet")
-            definition.excludeWhenSet = values;
-        if (method === "VisibilityDependsOn")
-            definition.visibilityTables = values;
-        if (method === "OrderBy" && values[0]) {
-            definition.orderBy = values[0];
-            definition.orderDirection = values[1]?.toLowerCase() === "asc" ? "asc" : "desc";
-        }
-        if (method === "Eager")
-            definition.mode = "eager";
-        if (method === "Progressive")
-            definition.mode = "progressive";
-        if (method === "Budget") {
-            const numbers = body.split(",").map((value) => Number(value.trim()));
-            if (Number.isFinite(numbers[0]) && numbers[0] > 0)
-                definition.maxRows = numbers[0];
-            if (Number.isFinite(numbers[1]) && numbers[1] > 0)
-                definition.maxBytes = numbers[1];
-        }
-        cursor = chainClose + 1;
-    }
-    if (!definition.columns.includes(definition.key))
-        definition.columns.push(definition.key);
-    return definition;
-}
-function parseFunctionDependencies(callBody) {
-    const dependencies = {};
-    const pattern = /(?:gonvex\.)?(Reads|Writes|ReadsEphemeral|WritesEphemeral|ShareByPermissions|ShareByVisibility|ShareResultFrom|OptimisticMutation|OptimisticProjection)\s*\(/g;
-    let match;
-    while ((match = pattern.exec(callBody)) !== null) {
-        const option = match[1];
-        const openParen = callBody.indexOf("(", match.index);
-        const closeParen = findClosingParen(callBody, openParen);
-        if (closeParen < 0)
-            break;
-        if (option === "ReadsEphemeral") {
-            dependencies.readsEphemeral = true;
-            pattern.lastIndex = closeParen + 1;
-            continue;
-        }
-        if (option === "WritesEphemeral") {
-            dependencies.writesEphemeral = true;
-            pattern.lastIndex = closeParen + 1;
-            continue;
-        }
-        if (option === "ShareByPermissions") {
-            dependencies.shareByPermissions = true;
-            pattern.lastIndex = closeParen + 1;
-            continue;
-        }
-        if (option === "ShareByVisibility") {
-            dependencies.shareByVisibility = stringArgs(callBody.slice(openParen + 1, closeParen))[0];
-            pattern.lastIndex = closeParen + 1;
-            continue;
-        }
-        if (option === "ShareResultFrom") {
-            const values = stringArgs(callBody.slice(openParen + 1, closeParen));
-            dependencies.shareResultFrom = values[0];
-            dependencies.shareResultField = values[1];
-            pattern.lastIndex = closeParen + 1;
-            continue;
-        }
-        if (option === "OptimisticMutation") {
-            const entity = stringArgs(callBody.slice(openParen + 1, closeParen))[0];
-            const definition = { entity: entity?.trim() ?? "", rowIdPath: [], fieldsPath: [] };
-            let cursor = closeParen + 1;
-            while (cursor < callBody.length) {
-                const chain = chainedGoMethod(callBody, cursor, "RowIDArg|FieldsArg");
-                if (!chain)
-                    break;
-                const chainClose = findClosingParen(callBody, chain.openParen);
-                if (chainClose < 0)
-                    break;
-                const path = cleanParsedOptimisticPath(stringArgs(callBody.slice(chain.openParen + 1, chainClose))[0] ?? "");
-                if (chain.method === "RowIDArg")
-                    definition.rowIdPath = path;
-                if (chain.method === "FieldsArg")
-                    definition.fieldsPath = path;
-                cursor = chainClose + 1;
-            }
-            if (definition.entity)
-                dependencies.optimisticMutation = definition;
-            pattern.lastIndex = cursor;
-            continue;
-        }
-        if (option === "OptimisticProjection") {
-            const entity = stringArgs(callBody.slice(openParen + 1, closeParen))[0];
-            const definition = { entity: entity?.trim() ?? "", key: "id", resultPath: [] };
-            let cursor = closeParen + 1;
-            while (cursor < callBody.length) {
-                const chain = chainedGoMethod(callBody, cursor, "Key|ResultPath");
-                if (!chain)
-                    break;
-                const chainClose = findClosingParen(callBody, chain.openParen);
-                if (chainClose < 0)
-                    break;
-                const value = stringArgs(callBody.slice(chain.openParen + 1, chainClose))[0] ?? "";
-                if (chain.method === "Key" && value.trim())
-                    definition.key = value.trim();
-                if (chain.method === "ResultPath")
-                    definition.resultPath = cleanParsedOptimisticPath(value);
-                cursor = chainClose + 1;
-            }
-            if (definition.entity)
-                dependencies.optimisticProjection = definition;
-            pattern.lastIndex = cursor;
-            continue;
-        }
-        const tables = stringArgs(callBody.slice(openParen + 1, closeParen));
-        const start = option === "Reads"
-            ? (dependencies.reads ??= []).push(...tables.map((table) => ({ table }))) - tables.length
-            : (dependencies.writes ??= []).push(...tables.map((table) => ({ table }))) - tables.length;
-        let cursor = closeParen + 1;
-        while (cursor < callBody.length) {
-            const chain = chainedGoMethod(callBody, cursor, "Columns|Filters|OrdersBy|Windowed|Predicate");
-            if (!chain)
-                break;
-            const chainOpen = chain.openParen;
-            const chainClose = findClosingParen(callBody, chainOpen);
-            if (chainClose < 0)
-                break;
-            const method = chain.method;
-            const values = stringArgs(callBody.slice(chainOpen + 1, chainClose));
-            if (option === "Reads") {
-                for (const dependency of (dependencies.reads ?? []).slice(start)) {
-                    if (method === "Columns" && values.length > 0)
-                        dependency.columns = values;
-                    if (method === "Filters" && values.length > 0)
-                        dependency.filters = values;
-                    if (method === "OrdersBy" && values.length > 0)
-                        dependency.ordersBy = values;
-                    if (method === "Windowed")
-                        dependency.windowed = true;
-                    if (method === "Predicate" && values[0])
-                        dependency.predicate = values[0];
-                }
-            }
-            else if (method === "Columns") {
-                for (const dependency of (dependencies.writes ?? []).slice(start)) {
-                    if (values.length > 0)
-                        dependency.columns = values;
-                }
-            }
-            cursor = chainClose + 1;
-        }
-        pattern.lastIndex = cursor;
-    }
-    return dependencies;
-}
-function chainedGoMethod(source, start, methods) {
-    let cursor = skipGoTrivia(source, start);
-    if (source[cursor] !== ".")
-        return undefined;
-    cursor = skipGoTrivia(source, cursor + 1);
-    const match = new RegExp(`^(${methods})\\b`).exec(source.slice(cursor));
-    if (!match)
-        return undefined;
-    const method = match[1];
-    cursor = skipGoTrivia(source, cursor + match[0].length);
-    if (source[cursor] !== "(")
-        return undefined;
-    return { method, openParen: cursor };
-}
-function skipGoTrivia(source, start) {
-    let cursor = start;
-    while (cursor < source.length) {
-        const char = source[cursor];
-        const next = source[cursor + 1] ?? "";
-        if (/\s/.test(char)) {
-            cursor += 1;
-            continue;
-        }
-        if (char === "/" && next === "/") {
-            const newline = source.indexOf("\n", cursor + 2);
-            return newline < 0 ? source.length : skipGoTrivia(source, newline + 1);
-        }
-        if (char === "/" && next === "*") {
-            const close = source.indexOf("*/", cursor + 2);
-            return close < 0 ? source.length : skipGoTrivia(source, close + 2);
-        }
-        break;
-    }
-    return cursor;
-}
-function findClosingParen(source, openParen) {
-    if (openParen < 0 || source[openParen] !== "(")
-        return -1;
-    let depth = 0;
-    let quote = "";
-    let escaped = false;
-    let lineComment = false;
-    let blockComment = false;
-    for (let index = openParen; index < source.length; index += 1) {
-        const char = source[index];
-        const next = source[index + 1] ?? "";
-        if (lineComment) {
-            if (char === "\n")
-                lineComment = false;
-            continue;
-        }
-        if (blockComment) {
-            if (char === "*" && next === "/") {
-                blockComment = false;
-                index += 1;
-            }
-            continue;
-        }
-        if (quote) {
-            if (quote !== "`" && escaped) {
-                escaped = false;
-                continue;
-            }
-            if (quote !== "`" && char === "\\") {
-                escaped = true;
-                continue;
-            }
-            if (char === quote)
-                quote = "";
-            continue;
-        }
-        if (char === "/" && next === "/") {
-            lineComment = true;
-            index += 1;
-            continue;
-        }
-        if (char === "/" && next === "*") {
-            blockComment = true;
-            index += 1;
-            continue;
-        }
-        if (char === '"' || char === "'" || char === "`") {
-            quote = char;
-            continue;
-        }
-        if (char === "(")
-            depth += 1;
-        if (char === ")") {
-            depth -= 1;
-            if (depth === 0)
-                return index;
-        }
-    }
-    return -1;
-}
-async function parseSchema(file) {
-    const source = await readFile(file, "utf8");
-    const tablePattern = /s\.(Table|TenantTable|LandlordTable)\(\s*"([^"]+)"\s*,\s*func\([^)]*\)\s*\{([\s\S]*?)\n\s*\}\s*\)/g;
-    const columnPattern = /t\.(ID|String|Text|Int|Int64|Float64|Bool|Time|JSON)\(\s*"([^"]+)"([^)]*)\)/g;
-    const indexPattern = /t\.(Index|UniqueIndex|TrigramIndex)\(\s*"([^"]+)"([^)]*)\)/g;
-    const schema = emptySchemaDefinition();
-    for (const tableMatch of source.matchAll(tablePattern)) {
-        const table = { columns: {}, indexes: {} };
-        const scope = tableMatch[1];
-        const name = tableMatch[2];
-        const body = tableMatch[3];
-        for (const columnMatch of body.matchAll(columnPattern)) {
-            const kind = columnMatch[1];
-            table.columns[columnMatch[2]] = {
-                type: columnType(kind),
-                nullable: columnMatch[3].includes("gonvex.Nullable"),
-                primaryKey: kind === "ID",
-            };
-        }
-        for (const indexMatch of body.matchAll(indexPattern)) {
-            table.indexes[indexMatch[2]] = {
-                columns: stringArgs(indexMatch[3]),
-                unique: indexMatch[1] === "UniqueIndex",
-                ...(indexMatch[1] === "TrigramIndex" ? { kind: "trigram" } : {}),
-            };
-        }
-        if (scope === "LandlordTable") {
-            schema.landlordTables[name] = table;
-        }
-        else {
-            schema.tenantTables[name] = table;
-            schema.tables[name] = table;
-        }
-    }
-    return schema;
-}
 async function writeBindings(root, manifest) {
     const dir = join(root, "gonvex", "_generated");
     await mkdir(dir, { recursive: true });
+    await rm(join(dir, "landlord"), { recursive: true, force: true });
     let changedFiles = 0;
     if (await writeManifestIfChanged(join(dir, "manifest.json"), manifest))
         changedFiles += 1;
     const outputs = {
         "api.ts": renderAPI(manifest),
-        "client.ts": '// Generated by gonvex dev. Do not edit.\nexport { GonvexClient, ConvexReactClient } from "@gonvex/client";\n',
-        "react.ts": '// Generated by gonvex dev. Do not edit.\nexport { ConvexProvider, ConvexProviderWithAuth, ConvexReactClient, createGonvexAuth, GonvexAuthProvider, GonvexGoogleAuthButton, GonvexProvider, useAction, useConvex, useConvexAuth, useConvexConnectionState, useGonvexAuth, useMutation, usePaginatedQuery, useQuery, useSync, useSyncSelector } from "@gonvex/react";\nexport type { GonvexAuthConfig, GonvexAuthTenant, GonvexAuthUser, GonvexAuthValue } from "@gonvex/react";\n',
+        "client.ts": '// Generated by gonvex dev. Do not edit.\nexport { GonvexClient } from "@gonvex/client";\n',
+        "react.ts": '// Generated by gonvex dev. Do not edit.\nexport { createGonvexAuth, GonvexAuthProvider, GonvexGoogleAuthButton, GonvexProvider, GonvexProviderWithAuth, useAction, useControlQuery, useCurrentTenantProfile, useEntity, useGonvexAuth, useGonvexAuthState, useGonvexClient, useGonvexConnectionState, useInvitationList, useLiveQuery, useLiveQueryState, useQuery, useReducer, useReplicaCollection, useReplicaCollectionState, useReplicaEntities, useReplicaSelector, useRetainedLiveQuery } from "@gonvex/react";\nexport type { GonvexAuthAccount, GonvexAuthConfig, GonvexAuthProviderName, GonvexAuthTenant, GonvexAuthValue, GonvexDeveloperModeState } from "@gonvex/react";\n',
         "types.ts": "// Generated by gonvex dev. Do not edit.\nexport type JsonValue = null | boolean | number | string | JsonValue[] | { [key: string]: JsonValue };\n",
         "schema.ts": renderSchemaIndex(manifest),
-        "landlord/schema.ts": renderScopedSchemaModule("landlord", manifest.schema.landlordTables),
-        "landlord/tables.ts": renderScopedTablesModule("landlord", manifest.schema.landlordTables),
+        "control-plane/schema.ts": renderScopedSchemaModule("control-plane", manifest.schema.controlPlaneTables),
+        "control-plane/tables.ts": renderScopedTablesModule("control-plane", manifest.schema.controlPlaneTables),
         "tenant/schema.ts": renderScopedSchemaModule("tenant", manifest.schema.tenantTables),
         "tenant/tables.ts": renderScopedTablesModule("tenant", manifest.schema.tenantTables),
+        // Module-artifact projects emit the artifact next to the manifest so the
+        // deploy payload is inspectable without re-running codegen.
+        ...(manifest.module ? { "module.json": `${JSON.stringify(manifest.module, null, 2)}\n` } : {}),
     };
     for (const [name, contents] of Object.entries(outputs)) {
         if (await writeFileIfChanged(join(dir, name), contents))
@@ -1463,113 +1126,214 @@ function functionEntryChanged(previous, current, path) {
     const currentEntry = current.functions[path];
     if (JSON.stringify(previousEntry) !== JSON.stringify(currentEntry))
         return true;
-    const previousBundleFile = bundleFileForFunction(previousEntry);
-    const currentBundleFile = bundleFileForFunction(currentEntry);
-    return previous.bundle?.files[previousBundleFile] !== current.bundle?.files[currentBundleFile];
+    return sourceForFunction(previous, previousEntry) !== sourceForFunction(current, currentEntry);
+}
+function sourceForFunction(manifest, entry) {
+    return manifest.module.files[normalizedFunctionFile(entry)];
 }
-function bundleFileForFunction(entry) {
-    const normalized = entry.file.replace(/\\/g, "/").replace(/^\.?\//, "");
-    const withoutGonvexPrefix = normalized.startsWith("gonvex/") ? normalized.slice("gonvex/".length) : normalized;
-    return `app/${withoutGonvexPrefix}`;
+function normalizedFunctionFile(entry) {
+    return entry.file.replace(/\\/g, "/").replace(/^\.?\//, "");
 }
 function renderAPI(manifest) {
-    const root = {};
-    const optimisticWrites = {};
-    const optimisticMutations = {};
+    const publicRoot = {};
+    const internalRoot = {};
+    const optimisticTransactions = {};
+    const functionTypes = [];
     for (const [path, entry] of Object.entries(manifest.functions).sort(([a], [b]) => a.localeCompare(b))) {
         const parts = path.split(".").filter(Boolean);
         if (parts.length === 0)
             continue;
-        let target = root;
+        let target = entry.internal ? internalRoot : publicRoot;
         for (const part of parts.slice(0, -1)) {
             target = target[part] ??= {};
         }
-        const reference = { kind: entry.kind, path };
-        const projection = entry.kind === "sync" && entry.sync
-            ? { entity: entry.sync.table, key: entry.sync.key, resultPath: [] }
-            : entry.dependencies?.optimisticProjection;
-        const mutation = entry.dependencies?.optimisticMutation;
-        if (projection || mutation) {
-            reference.optimistic = {
-                ...(projection ? { projection } : {}),
-                ...(mutation ? { mutation } : {}),
-            };
+        const reference = {
+            kind: entry.kind,
+            path,
+            __argsType: functionTypeName(path, "Args"),
+            __resultType: functionTypeName(path, "Result"),
+            ...(entry.delivery ? { delivery: entry.delivery } : {}),
+            ...(entry.offline !== undefined ? { offline: entry.offline } : {}),
+            ...(isModuleSchema(entry.args) ? { args: entry.args } : {}),
+            ...(isModuleSchema(entry.result) ? { result: entry.result } : {}),
+        };
+        if (entry.delivery === "live" && entry.dependencies?.liveQueryPlan) {
+            const plan = entry.dependencies.liveQueryPlan;
+            reference.live = { entity: plan.table, key: plan.key, resultPath: plan.resultPath ?? [], plan };
         }
-        target[parts[parts.length - 1]] = reference;
-        if (entry.kind === "mutation" && entry.dependencies?.writes?.length) {
-            optimisticWrites[path] = entry.dependencies.writes;
+        const transaction = entry.kind === "reducer" ? entry.optimistic : undefined;
+        if (transaction !== undefined) {
+            reference.optimistic = { transaction };
         }
-        if (entry.kind === "mutation" && mutation)
-            optimisticMutations[path] = mutation;
+        target[parts[parts.length - 1]] = reference;
+        if (entry.kind === "reducer" && transaction !== undefined)
+            optimisticTransactions[path] = transaction;
+        functionTypes.push({
+            path,
+            args: functionTypeName(path, "Args"),
+            result: functionTypeName(path, "Result"),
+        });
     }
     const lines = [
         "// Generated by gonvex dev. Do not edit.",
         "",
-        `export const api = ${renderObject(root, 0)} as const;`,
+        "import { control as gonvexControl, type LiveQueryPlan } from \"@gonvex/client\";",
         "",
-        "export const internal = api;",
+        "export type JsonValue = null | boolean | number | string | JsonValue[] | { [key: string]: JsonValue };",
+        "export type FunctionKind = \"query\" | \"reducer\" | \"action\";",
+        "export type OptimisticID = string | readonly string[];",
+        "export type OptimisticValue = JsonValue | { readonly $arg: string | readonly string[] } | readonly OptimisticValue[] | { readonly [key: string]: OptimisticValue };",
+        "export type OptimisticEffectDefinition =",
+        "  | { readonly operation: \"patch\"; readonly entity: string; readonly id: OptimisticID; readonly fields: Readonly<Record<string, OptimisticValue>> }",
+        "  | { readonly operation: \"upsert\"; readonly entity: string; readonly id: OptimisticID; readonly value: Readonly<Record<string, OptimisticValue>> }",
+        "  | { readonly operation: \"delete\"; readonly entity: string; readonly id: OptimisticID };",
+        "export type OptimisticTransactionDefinition = { readonly effects: readonly OptimisticEffectDefinition[]; readonly expectedRevision?: number };",
+        "export type FunctionReference<Kind extends FunctionKind = FunctionKind, Args = JsonValue, Result = JsonValue> = {",
+        "  readonly kind: Kind;",
+        "  readonly path: string;",
+        "  readonly delivery?: \"oneShot\" | \"live\" | \"replica\";",
+        "  readonly offline?: { readonly mode: \"forbidden\" | \"allowed\" | \"onlineOnly\"; readonly conflict?: \"reject\" | \"expectedVersion\" | \"merge\"; readonly reason?: string };",
+        "  readonly args?: Args;",
+        "  readonly result?: Result;",
+        "  readonly live?: { readonly entity: string; readonly key: string; readonly resultPath?: readonly string[]; readonly plan: LiveQueryPlan };",
+        "  readonly optimistic?: { readonly transaction?: OptimisticTransactionDefinition };",
+        "};",
+        "",
+        ...functionTypes.flatMap(({ path, args, result }) => [
+            `export type ${args} = ${renderSchemaType(manifest.functions[path]?.args)};`,
+            `export type ${result} = ${renderSchemaType(manifest.functions[path]?.result)};`,
+        ]),
+        "",
+        `export const api = ${renderObject(publicRoot, 0)} as const;`,
+        "",
+        "export const control = gonvexControl;",
+        "",
+        `export const internal = ${renderObject(internalRoot, 0)} as const;`,
         "export type Api = typeof api;",
         "",
-        `export const optimisticWrites: Record<string, Array<{ table: string; columns?: string[] }>> = ${renderObject(optimisticWrites, 0)};`,
-        `export const optimisticMutations: Record<string, { entity: string; rowIdPath: string[]; fieldsPath: string[] }> = ${renderObject(optimisticMutations, 0)};`,
+        `export const optimisticTransactions: Record<string, OptimisticTransactionDefinition> = ${renderObject(optimisticTransactions, 0)};`,
+        "",
+        "export type ApiArgs = {",
+        ...functionTypes.map(({ path, args }) => `  ${JSON.stringify(path)}: ${args};`),
+        "};",
+        "",
+        "export type ApiResults = {",
+        ...functionTypes.map(({ path, result }) => `  ${JSON.stringify(path)}: ${result};`),
+        "};",
         "",
         "export function optimisticPatchesFor(",
         "  path: string,",
         "  args: Record<string, unknown>,",
-        "): Array<{ entity?: string; collection?: string; rowId: string; op: \"patch\"; fields: Record<string, unknown> }> {",
-        "  const mutation = Object.prototype.hasOwnProperty.call(optimisticMutations, path)",
-        "    ? optimisticMutations[path]",
+        "): Array<{ entity?: string; collection?: string; rowId: string; op: \"patch\" | \"insert\" | \"upsert\" | \"delete\"; fields?: Record<string, unknown> }> {",
+        "  const transaction = Object.prototype.hasOwnProperty.call(optimisticTransactions, path)",
+        "    ? optimisticTransactions[path]",
         "    : undefined;",
-        "  if (mutation) {",
-        "    const readPath = (value: unknown, segments: string[]): unknown =>",
+        "  if (transaction && Array.isArray(transaction.effects) && transaction.effects.length > 0) {",
+        "    const readPath = (value: unknown, segments: readonly string[]): unknown =>",
         "      segments.reduce<unknown>((current, segment) =>",
         "        current && typeof current === \"object\" ? (current as Record<string, unknown>)[segment] : undefined, value);",
-        "    const rowId = String(readPath(args, mutation.rowIdPath) ?? args.id ?? args._id ?? \"\");",
-        "    const nested = readPath(args, mutation.fieldsPath);",
-        "    if (rowId && nested && typeof nested === \"object\" && !Array.isArray(nested)) {",
-        "      return [{ entity: mutation.entity, rowId, op: \"patch\" as const, fields: { ...(nested as Record<string, unknown>) } }];",
+        "    const resolveValue = (value: unknown): unknown => {",
+        "      if (Array.isArray(value)) return value.map(resolveValue);",
+        "      if (!value || typeof value !== \"object\") return value;",
+        "      const record = value as Record<string, unknown>;",
+        "      if (Object.keys(record).length === 1 && Object.prototype.hasOwnProperty.call(record, \"$arg\")) {",
+        "        const path = record.$arg;",
+        "        const segments = Array.isArray(path)",
+        "          ? path.filter((part): part is string => typeof part === \"string\" && part.trim().length > 0)",
+        "          : typeof path === \"string\" ? path.split(\".\").map((part) => part.trim()).filter(Boolean) : [];",
+        "        return segments.length > 0 ? readPath(args, segments) : undefined;",
+        "      }",
+        "      return Object.fromEntries(Object.entries(record).map(([key, item]) => [key, resolveValue(item)]));",
+        "    };",
+        "    const containsUndefined = (value: unknown): boolean =>",
+        "      value === undefined || (Array.isArray(value)",
+        "        ? value.some(containsUndefined)",
+        "        : !!value && typeof value === \"object\" && Object.values(value as Record<string, unknown>).some(containsUndefined));",
+        "    const patches: Array<{ entity?: string; collection?: string; rowId: string; op: \"patch\" | \"insert\" | \"upsert\" | \"delete\"; fields?: Record<string, unknown> }> = [];",
+        "    for (const effect of transaction.effects) {",
+        "      const rawId = Array.isArray(effect.id) ? readPath(args, effect.id) : effect.id;",
+        "      const rowId = String(rawId ?? \"\").trim();",
+        "      if (!rowId || !effect.entity) return [];",
+        "      if (effect.operation === \"delete\") {",
+        "        patches.push({ entity: effect.entity, rowId, op: \"delete\" });",
+        "        continue;",
+        "      }",
+        "      const template = effect.operation === \"patch\" ? effect.fields : effect.value;",
+        "      if (!template || typeof template !== \"object\" || Array.isArray(template)) return [];",
+        "      const fields = resolveValue(template);",
+        "      if (!fields || typeof fields !== \"object\" || Array.isArray(fields) || containsUndefined(fields)) return [];",
+        "      patches.push({ entity: effect.entity, rowId, op: effect.operation === \"upsert\" ? \"upsert\" : \"patch\", fields: { ...(fields as Record<string, unknown>) } });",
         "    }",
+        "    return patches;",
         "  }",
-        "  const writes = optimisticWrites[path];",
-        "  const rowId = String(args.id ?? args._id ?? \"\");",
-        "  if (!Array.isArray(writes) || rowId === \"\") return [];",
-        "",
-        "  return writes.map(({ table, columns }) => ({",
-        "    collection: table,",
-        "    rowId,",
-        "    op: \"patch\" as const,",
-        "    fields: Object.fromEntries(",
-        "      Object.entries(args).filter(([key]) =>",
-        "        columns",
-        "          ? columns.includes(key)",
-        "          : key !== \"id\" && key !== \"_id\" && key !== \"tenantId\",",
-        "      ),",
-        "    ),",
-        "  }));",
+        "  return [];",
         "}",
         "",
     ];
     return lines.join("\n");
 }
+function functionTypeName(path, suffix) {
+    const parts = path.split(/[^A-Za-z0-9_$]+/).filter(Boolean);
+    const stem = parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("") || "Function";
+    return `${/^[0-9]/.test(stem) ? "Fn" : ""}${stem}${suffix}`;
+}
+function renderSchemaType(schema) {
+    if (!schema)
+        return "JsonValue";
+    switch (schema.kind) {
+        case "string": return "string";
+        case "number": return "number";
+        case "boolean": return "boolean";
+        case "null": return "null";
+        case "any": return "JsonValue";
+        case "id": return "string";
+        case "literal": return renderLiteralType(schema.value);
+        case "array": return `Array<${renderSchemaType(schema.items)}>`;
+        case "record": return `Record<string, ${renderSchemaType(schema.values)}>`;
+        case "optional": return `${renderSchemaType(schema.value)} | undefined`;
+        case "object": {
+            const fields = Object.entries(schema.fields).map(([key, value]) => {
+                const property = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+                const optional = value.kind === "optional" ? "?" : "";
+                return `  ${property}${optional}: ${renderSchemaType(value)};`;
+            });
+            if (schema.allowUnknown)
+                fields.push("  [key: string]: JsonValue;");
+            return fields.length === 0 ? "{ }" : `{\n${fields.join("\n")}\n}`;
+        }
+    }
+}
+function renderLiteralType(value) {
+    if (value === null)
+        return "null";
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (typeof value === "boolean" || typeof value === "number")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(renderLiteralType).join(", ")}]`;
+    const fields = Object.entries(value).map(([key, nested]) => `${JSON.stringify(key)}: ${renderLiteralType(nested)}`);
+    return fields.length === 0 ? "{ }" : `{ ${fields.join(", ")} }`;
+}
 function renderSchemaIndex(manifest) {
-    const landlord = renderSchemaObject("landlord", manifest.schema.landlordTables, 0);
+    const controlPlane = renderSchemaObject("control-plane", manifest.schema.controlPlaneTables, 0);
     const tenant = renderSchemaObject("tenant", manifest.schema.tenantTables, 0);
     return [
         "// Generated by gonvex dev. Do not edit.",
         "",
-        `export const landlord = ${landlord} as const;`,
+        `export const controlPlane = ${controlPlane} as const;`,
         "",
         `export const tenant = ${tenant} as const;`,
         "",
         "export const tables = tenant.tables;",
         "",
         "export const schema = {",
-        "  landlord,",
+        "  controlPlane,",
         "  tenant,",
         "  tables,",
         "} as const;",
         "",
-        "export type LandlordTableName = keyof typeof landlord.tables;",
+        "export type ControlPlaneTableName = keyof typeof controlPlane.tables;",
         "export type TenantTableName = keyof typeof tenant.tables;",
         "export type TableName = TenantTableName;",
         "",
@@ -1581,6 +1345,7 @@ function renderScopedSchemaModule(scope, tables) {
         "",
         `export const schema = ${renderSchemaObject(scope, tables, 0)} as const;`,
         "",
+        ...(scope === "control-plane" ? ["export const controlPlane = schema;"] : ["export const tenant = schema;"]),
         "export const tables = schema.tables;",
         "",
         "export type TableName = keyof typeof tables;",
@@ -1607,7 +1372,8 @@ function renderObject(value, depth) {
         return JSON.stringify(value);
     const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
     if (isFunctionRef(value)) {
-        return `{ kind: ${JSON.stringify(value.kind)}, path: ${JSON.stringify(value.path)} }`;
+        const visible = Object.fromEntries(entries.filter(([key]) => !key.startsWith("__")));
+        return `${renderObject(visible, depth)} as unknown as FunctionReference<${JSON.stringify(value.kind)}, ${value.__argsType}, ${value.__resultType}>`;
     }
     const indent = "  ".repeat(depth);
     const childIndent = "  ".repeat(depth + 1);
@@ -1619,7 +1385,10 @@ function renderObject(value, depth) {
     return lines.join("\n");
 }
 function isFunctionRef(value) {
-    return typeof value.kind === "string" && typeof value.path === "string" && Object.keys(value).length === 2;
+    return typeof value.kind === "string"
+        && typeof value.path === "string"
+        && typeof value.__argsType === "string"
+        && typeof value.__resultType === "string";
 }
 function propertyKey(key) {
     return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
@@ -1627,12 +1396,12 @@ function propertyKey(key) {
 function emptySchemaDefinition() {
     return {
         tables: {},
-        landlordTables: {},
+        controlPlaneTables: {},
         tenantTables: {},
     };
 }
 function mergeSchemaDefinition(target, source) {
-    Object.assign(target.landlordTables, source.landlordTables);
+    Object.assign(target.controlPlaneTables, source.controlPlaneTables);
     Object.assign(target.tenantTables, source.tenantTables);
     target.tables = target.tenantTables;
 }
@@ -1648,6 +1417,8 @@ async function syncRuntime(settings, manifest) {
     });
     if (!response.ok)
         throw new Error(`runtime returned ${response.status} ${response.statusText}: ${await response.text()}`);
+    const payload = await response.json();
+    return payload.schemaDefinition;
 }
 async function fetchProjectEnv(settings) {
     const response = await fetch(projectEnvURL(settings), {
@@ -1769,9 +1540,12 @@ async function runtimeHasManifest(settings, manifest) {
         return false;
     const current = await response.json();
     return current.project === manifest.project
-        && current.bundle?.hash === manifest.bundle?.hash
+        && deployedSourceHash(current) === deployedSourceHash(manifest)
         && Object.keys(current.functions ?? {}).length === Object.keys(manifest.functions ?? {}).length;
 }
+function deployedSourceHash(manifest) {
+    return manifest.module.hash;
+}
 async function ensureProjectSettings(root, settings, options) {
     if (settings.key)
         return settings;
@@ -2229,24 +2003,6 @@ function loadDotEnv(path) {
 function readFileSyncText(path) {
     return existsSync(path) ? readFileSync(path, "utf8") : "";
 }
-async function goFiles(root) {
-    if (!existsSync(root))
-        return [];
-    const entries = await readdir(root, { withFileTypes: true });
-    const files = [];
-    for (const entry of entries) {
-        const path = join(root, entry.name);
-        if (entry.isDirectory()) {
-            if (entry.name === "_generated")
-                continue;
-            files.push(...await goFiles(path));
-        }
-        else if (entry.isFile() && entry.name.endsWith(".go")) {
-            files.push(path);
-        }
-    }
-    return files.sort();
-}
 async function migrationFiles(root) {
     if (!existsSync(root))
         return [];
@@ -2280,6 +2036,8 @@ async function copyTemplate(template, target, options = {}) {
 async function copyDir(source, target, overwrite) {
     await mkdir(target, { recursive: true });
     for (const entry of await readdir(source, { withFileTypes: true })) {
+        if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "_build")
+            continue;
         const sourcePath = join(source, entry.name);
         const targetPath = join(target, entry.name === "_gitignore" ? ".gitignore" : entry.name);
         if (entry.isDirectory()) {
@@ -2329,45 +2087,6 @@ function templateDir(template) {
         return packageTemplate;
     return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "templates", template);
 }
-function functionKind(raw) {
-    if (raw === "InternalMutation")
-        return "internalMutation";
-    if (raw === "LiveGrid")
-        return "liveGrid";
-    if (raw === "Sync")
-        return "sync";
-    if (raw === "PublicHTTP")
-        return "http";
-    return raw.toLowerCase();
-}
-function columnType(kind) {
-    if (kind === "ID")
-        return "id";
-    if (kind === "Int64")
-        return "int64";
-    if (kind === "Float64")
-        return "float64";
-    return kind.toLowerCase();
-}
-function stringArgs(input) {
-    const values = [];
-    for (const match of input.matchAll(/"((?:\\.|[^"\\])*)"|`([^`]*)`/g)) {
-        if (match[2] !== undefined) {
-            values.push(match[2]);
-            continue;
-        }
-        try {
-            values.push(JSON.parse(`"${match[1] ?? ""}"`));
-        }
-        catch {
-            values.push(match[1] ?? "");
-        }
-    }
-    return values;
-}
-function cleanParsedOptimisticPath(value) {
-    return value.split(".").map((segment) => segment.trim()).filter(Boolean);
-}
 function valueFor(args, key) {
     const index = args.indexOf(key);
     if (index === -1)
@@ -2430,13 +2149,13 @@ function printAuthHelp() {
     console.log("  gonvex auth remove google [--origin URL]... [--callback-path /]");
     console.log("  gonvex auth status [--json]");
     console.log("  gonvex auth doctor [--json]");
-    console.log("  gonvex auth users [--json]");
+    console.log("  gonvex auth accounts [--json]");
     console.log("  gonvex auth tenants list [--json]");
     console.log("  gonvex auth tenants create <name> [--owner <email>]");
     console.log("  gonvex auth memberships list --tenant <tenant-id> [--json]");
     console.log("  gonvex auth memberships add --tenant <tenant-id> --email <email> [--role member]");
-    console.log("  gonvex auth memberships remove --tenant <tenant-id> (--user <user-id> | --email <invited-email>)");
-    console.log("  gonvex auth user <disable|enable|delete> <user-id>");
+    console.log("  gonvex auth memberships remove --tenant <tenant-id> (--member <member-id> | --email <invited-email>)");
+    console.log("  gonvex auth account <disable|enable|delete> <account-id>");
 }
 function printEnvHelp() {
     console.log("Usage: gonvex env <command> [options]");