siteplane 0.1.48 → 0.1.50

package/dist/next.js

@@ -2,7 +2,7 @@
 import { execFile as execFile4 } from "child_process";
 import { createHash as createHash5 } from "crypto";
 import { readFile as readFile13 } from "fs/promises";
-import { dirname as dirname9, join as join12, resolve as resolve4 } from "path";
+import { dirname as dirname9, join as join13, resolve as resolve4 } from "path";
 import { promisify as promisify4 } from "util";
 
 // ../cli/dist/analytics/manifest.js
@@ -11,7 +11,7 @@ import { dirname } from "path";
 
 // ../shared/dist/actors.js
 import { z } from "zod";
-var ACTOR_TYPES = ["workspace_member", "site_member", "agent", "system"];
+var ACTOR_TYPES = ["workspace_member", "site_member", "agent", "setup_guest", "system"];
 var actorTypeSchema = z.enum(ACTOR_TYPES);
 
 // ../shared/dist/analytics-defaults.js
@@ -1563,7 +1563,7 @@ var siteSetupTaskSchema = z16.object({
   progress: siteSetupTaskProgressSchema.nullable(),
   deployment: setupDeploymentRecordSchema.nullable(),
   revalidationGeneration: z16.number().int().positive(),
-  assignment: z16.literal("owned"),
+  assignment: z16.enum(["owned", "provisional", "claimed"]),
   deadline: z16.string().datetime().nullable(),
   userInstructions: z16.object({
     text: siteSetupOwnerEditabilityNoteSchema,
@@ -2237,6 +2237,17 @@ var checkSetupAssetTargetInputSchema = z25.object({
   intent: z25.enum(["start", "poll"])
 }).strict();
 
+// ../shared/dist/setup-installation.js
+import { z as z26 } from "zod";
+var setupInstallationRequestSchema = z26.object({
+  modules: siteSetupModulesSchema,
+  ownerEditabilityNote: siteSetupOwnerEditabilityNoteSchema,
+  provider: z26.object({
+    projectId: z26.string().min(1).max(200),
+    teamId: z26.string().min(1).max(200)
+  }).strict()
+}).strict();
+
 // ../cli/dist/analytics/static-scan.js
 import ts from "typescript";
 
@@ -2289,16 +2300,16 @@ function createAnalyticsCliRequestHeaders(config) {
 }
 
 // ../cli/dist/commands/analytics/public-key.js
-import { z as z26 } from "zod";
-var responseSchema = z26.object({
-  ok: z26.literal(true),
-  data: z26.object({
-    rawPublicKey: z26.string().regex(/^pk_siteplane_[A-Za-z0-9_-]{16}_[A-Za-z0-9_-]{43}$/)
+import { z as z27 } from "zod";
+var responseSchema = z27.object({
+  ok: z27.literal(true),
+  data: z27.object({
+    rawPublicKey: z27.string().regex(/^pk_siteplane_[A-Za-z0-9_-]{16}_[A-Za-z0-9_-]{43}$/)
   })
 });
-var errorResponseSchema = z26.object({
-  error: z26.object({
-    code: z26.string().regex(/^[a-z][a-z0-9_.-]+$/u)
+var errorResponseSchema = z27.object({
+  error: z27.object({
+    code: z27.string().regex(/^[a-z][a-z0-9_.-]+$/u)
   })
 });
 async function analyticsPublicKeyCommand(input) {
@@ -2320,13 +2331,13 @@ async function analyticsPublicKeyCommand(input) {
 }
 
 // ../cli/dist/commands/analytics/prepare.js
-import { z as z27 } from "zod";
-var resultSchema = z27.object({
-  ok: z27.literal(true),
-  data: z27.object({
-    rawPublicKey: z27.string().regex(/^pk_siteplane_[A-Za-z0-9_-]{16}_[A-Za-z0-9_-]{43}$/u),
-    generation: z27.number().int().positive(),
-    status: z27.enum([
+import { z as z28 } from "zod";
+var resultSchema = z28.object({
+  ok: z28.literal(true),
+  data: z28.object({
+    rawPublicKey: z28.string().regex(/^pk_siteplane_[A-Za-z0-9_-]{16}_[A-Za-z0-9_-]{43}$/u),
+    generation: z28.number().int().positive(),
+    status: z28.enum([
       "setup_started",
       "test_mode",
       "active",
@@ -2336,8 +2347,8 @@ var resultSchema = z27.object({
     ])
   }).strict()
 }).strict();
-var errorSchema = z27.object({
-  error: z27.object({ code: z27.string().regex(/^[a-z][a-z0-9_.-]+$/u) })
+var errorSchema = z28.object({
+  error: z28.object({ code: z28.string().regex(/^[a-z][a-z0-9_.-]+$/u) })
 });
 
 // ../cli/dist/commands/analytics/test.js
@@ -2370,19 +2381,19 @@ ${bookingRulesTemplate}`;
 import { access, chmod, open, readFile as readFile5, rename, rm } from "fs/promises";
 import { randomUUID as randomUUID2 } from "crypto";
 import { join as join3 } from "path";
-import { z as z28 } from "zod";
-var siteplaneProjectConfigSchema = z28.object({
-  version: z28.literal(2),
-  apiBaseUrl: z28.string().url(),
-  siteId: z28.string().uuid(),
-  publicSiteKeyId: z28.string().uuid(),
-  publicSiteKey: z28.string().trim().min(1),
-  runId: z28.string().uuid(),
-  appDirectory: z28.string().min(1),
-  taskContractVersion: z28.literal("siteplane.setup-task.v2"),
-  adminProtocolVersion: z28.literal(2),
+import { z as z29 } from "zod";
+var siteplaneProjectConfigSchema = z29.object({
+  version: z29.literal(2),
+  apiBaseUrl: z29.string().url(),
+  siteId: z29.string().uuid(),
+  publicSiteKeyId: z29.string().uuid(),
+  publicSiteKey: z29.string().trim().min(1),
+  runId: z29.string().uuid(),
+  appDirectory: z29.string().min(1),
+  taskContractVersion: z29.literal("siteplane.setup-task.v2"),
+  adminProtocolVersion: z29.literal(2),
   packages: siteSetupPackagesSchema,
-  fieldContractHash: z28.string().regex(/^sha256:[0-9a-f]{64}$/iu).optional()
+  fieldContractHash: z29.string().regex(/^sha256:[0-9a-f]{64}$/iu).optional()
 }).strict();
 async function readProjectConfig(projectDir) {
   return siteplaneProjectConfigSchema.parse(JSON.parse(await readFile5(join3(projectDir, "siteplane.config.json"), "utf8")));
@@ -2394,15 +2405,27 @@ import { randomUUID as randomUUID3 } from "crypto";
 import { chmod as chmod2, lstat, mkdir as mkdir5, open as open2, readFile as readFile6, rename as rename2, rm as rm2 } from "fs/promises";
 import { dirname as dirname5, join as join4, relative } from "path";
 import { promisify } from "util";
-import { z as z29 } from "zod";
-var siteplaneCredentialsSchema = z29.object({
-  accessToken: z29.string().trim().min(1),
-  siteRevalidationSecret: z29.string().trim().min(1),
-  adminSession: z29.object({
-    secret: z29.string().regex(/^[A-Za-z0-9_-]{43}$/u),
-    generation: z29.string().uuid()
+import { z as z30 } from "zod";
+var localSetupInstallationSchema = z30.object({
+  key: z30.string().regex(/^[A-Za-z0-9_-]{43}$/u),
+  idempotencyKey: z30.string().uuid(),
+  apiBaseUrl: z30.string().url(),
+  request: setupInstallationRequestSchema,
+  bootstrapAcknowledged: z30.boolean()
+}).strict();
+var siteplaneCredentialsSchema = z30.object({
+  accessToken: z30.string().trim().min(1),
+  siteRevalidationSecret: z30.string().trim().min(1),
+  installation: localSetupInstallationSchema.optional(),
+  adminSession: z30.object({
+    secret: z30.string().regex(/^[A-Za-z0-9_-]{43}$/u),
+    generation: z30.string().uuid()
   }).strict().optional()
 }).strict();
+var localSetupCredentialsSchema = z30.union([
+  siteplaneCredentialsSchema,
+  z30.object({ installation: localSetupInstallationSchema }).strict()
+]);
 async function assertLocalCredentialsPathSafe(projectDir, options = {}) {
   const path = join4(projectDir, ".siteplane/credentials.json");
   await assertCredentialFilesystemSafe(projectDir);
@@ -2438,8 +2461,15 @@ async function assertCredentialFilesystemSafe(projectDir) {
   }
 }
 async function readLocalCredentials(projectDir) {
+  const credentials = await readLocalSetupCredentials(projectDir);
+  if (!("accessToken" in credentials)) {
+    throw new Error("setup_exchange_pending: Run siteplane setup start to finish the stored installation exchange.");
+  }
+  return credentials;
+}
+async function readLocalSetupCredentials(projectDir) {
   await assertCredentialFilesystemSafe(projectDir);
-  return siteplaneCredentialsSchema.parse(JSON.parse(await readFile6(join4(projectDir, ".siteplane/credentials.json"), "utf8")));
+  return localSetupCredentialsSchema.parse(JSON.parse(await readFile6(join4(projectDir, ".siteplane/credentials.json"), "utf8")));
 }
 var execFileAsync = promisify(execFile);
 async function gitPathMatches(projectDir, path, command) {
@@ -2455,7 +2485,7 @@ async function gitPathMatches(projectDir, path, command) {
 // ../cli/dist/commands/init.js
 import { access as access3 } from "fs/promises";
 import { join as join7, relative as relative3 } from "path";
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 
 // ../cli/dist/commands/setup-preflight.js
 import { createHash as createHash2 } from "crypto";
@@ -2467,11 +2497,11 @@ import { parse as parseYaml } from "yaml";
 import { createRequire } from "module";
 import { readFile as readFile7 } from "fs/promises";
 import { join as join5 } from "path";
-import { z as z30 } from "zod";
-var packageSchema = z30.object({
-  name: z30.string().optional(),
-  version: z30.string(),
-  peerDependencies: z30.record(z30.string(), z30.string()).optional()
+import { z as z31 } from "zod";
+var packageSchema = z31.object({
+  name: z31.string().optional(),
+  version: z31.string(),
+  peerDependencies: z31.record(z31.string(), z31.string()).optional()
 });
 async function readInstalledPackage(projectDir, name2) {
   const require2 = createRequire(join5(projectDir, "package.json"));
@@ -2489,7 +2519,7 @@ async function readInstalledPackage(projectDir, name2) {
 // ../cli/dist/commands/setup-preflight.js
 import { access as access2, readFile as readFile8, realpath, readdir, readlink } from "fs/promises";
 import { dirname as dirname6, join as join6, relative as relative2, resolve, sep } from "path";
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 
 // ../cli/dist/commands/setup-process.js
 import { spawn } from "child_process";
@@ -2590,29 +2620,29 @@ async function setupVercelApi(cwd, endpoint, body, method, options) {
 }
 
 // ../cli/dist/commands/setup-preflight.js
-var manifestSchema = z31.object({
-  packageManager: z31.string().optional(),
-  engines: z31.object({ node: z31.string().optional() }).optional(),
-  dependencies: z31.record(z31.string(), z31.string()).optional(),
-  devDependencies: z31.record(z31.string(), z31.string()).optional(),
-  scripts: z31.record(z31.string(), z31.string()).optional(),
-  workspaces: z31.unknown().optional()
+var manifestSchema = z32.object({
+  packageManager: z32.string().optional(),
+  engines: z32.object({ node: z32.string().optional() }).optional(),
+  dependencies: z32.record(z32.string(), z32.string()).optional(),
+  devDependencies: z32.record(z32.string(), z32.string()).optional(),
+  scripts: z32.record(z32.string(), z32.string()).optional(),
+  workspaces: z32.unknown().optional()
 });
-var vercelProjectSchema = z31.object({
-  id: z31.string(),
-  accountId: z31.string(),
-  name: z31.string(),
-  nodeVersion: z31.string().nullable().optional(),
-  rootDirectory: z31.string().nullable().optional(),
-  framework: z31.string().nullable().optional(),
-  installCommand: z31.string().nullable().optional(),
-  buildCommand: z31.string().nullable().optional(),
-  link: z31.object({
-    type: z31.string(),
-    repo: z31.string().optional(),
-    repoId: z31.union([z31.string(), z31.number()]).optional(),
-    org: z31.string().optional(),
-    productionBranch: z31.string().optional()
+var vercelProjectSchema = z32.object({
+  id: z32.string(),
+  accountId: z32.string(),
+  name: z32.string(),
+  nodeVersion: z32.string().nullable().optional(),
+  rootDirectory: z32.string().nullable().optional(),
+  framework: z32.string().nullable().optional(),
+  installCommand: z32.string().nullable().optional(),
+  buildCommand: z32.string().nullable().optional(),
+  link: z32.object({
+    type: z32.string(),
+    repo: z32.string().optional(),
+    repoId: z32.union([z32.string(), z32.number()]).optional(),
+    org: z32.string().optional(),
+    productionBranch: z32.string().optional()
   }).nullable().optional()
 });
 var exists = async (path) => access2(path).then(() => true, () => false);
@@ -2669,9 +2699,9 @@ async function inspectSetupLocalProject(projectDir) {
   const rootManifest = manifestSchema.parse(JSON.parse(await readFile8(join6(lockfileRoot, "package.json"), "utf8")));
   if (lockfileRoot !== projectDirectory) {
     const workspaceFile = join6(lockfileRoot, "pnpm-workspace.yaml");
-    const workspace = lockName === "pnpm-lock.yaml" && await exists(workspaceFile) ? z31.object({ packages: z31.array(z31.string()) }).parse(parseYaml(await readFile8(workspaceFile, "utf8"))).packages : z31.union([
-      z31.array(z31.string()),
-      z31.object({ packages: z31.array(z31.string()) }).transform((value) => value.packages)
+    const workspace = lockName === "pnpm-lock.yaml" && await exists(workspaceFile) ? z32.object({ packages: z32.array(z32.string()) }).parse(parseYaml(await readFile8(workspaceFile, "utf8"))).packages : z32.union([
+      z32.array(z32.string()),
+      z32.object({ packages: z32.array(z32.string()) }).transform((value) => value.packages)
     ]).parse(rootManifest.workspaces);
     const selected = relative2(lockfileRoot, projectDirectory).split(sep).join("/");
     if (!workspace.some((pattern) => !pattern.startsWith("!") && minimatch(selected, pattern)) || workspace.some((pattern) => pattern.startsWith("!") && minimatch(selected, pattern.slice(1))))
@@ -2685,11 +2715,11 @@ async function inspectSetupLocalProject(projectDir) {
       break;
   }
   const lockText = await readFile8(join6(lockfileRoot, lockName), "utf8");
-  const npmLock = lockName === "package-lock.json" ? z31.object({
-    lockfileVersion: z31.number(),
-    packages: z31.record(z31.string(), z31.object({
-      version: z31.string().optional(),
-      peerDependencies: z31.record(z31.string(), z31.string()).optional()
+  const npmLock = lockName === "package-lock.json" ? z32.object({
+    lockfileVersion: z32.number(),
+    packages: z32.record(z32.string(), z32.object({
+      version: z32.string().optional(),
+      peerDependencies: z32.record(z32.string(), z32.string()).optional()
     })).optional()
   }).parse(JSON.parse(lockText)) : null;
   async function version2(name3) {
@@ -2829,9 +2859,9 @@ async function setupPreflightCommand(input) {
       linkDirectory = dirname6(linkDirectory);
     if (!await exists(join6(linkDirectory, ".vercel/project.json")))
       fail("vercel_project_not_linked", "Link this application to its intended Vercel project before setup; Siteplane will not guess a target.");
-    const linked = z31.object({
-      projectId: z31.string().regex(/^prj_[A-Za-z0-9]+$/u),
-      orgId: z31.string().regex(/^(?:team|user)_[A-Za-z0-9]+$/u)
+    const linked = z32.object({
+      projectId: z32.string().regex(/^prj_[A-Za-z0-9]+$/u),
+      orgId: z32.string().regex(/^(?:team|user)_[A-Za-z0-9]+$/u)
     }).parse(JSON.parse(await readFile8(join6(linkDirectory, ".vercel/project.json"), "utf8")));
     const project = vercelProjectSchema.parse(await setupVercelApi(linkDirectory, `/v9/projects/${linked.projectId}?teamId=${linked.orgId}`));
     if (project.id !== linked.projectId || project.accountId !== linked.orgId)
@@ -2845,11 +2875,11 @@ async function setupPreflightCommand(input) {
       fail("vercel_production_branch_conflict", "The local branch differs from the bound Vercel Production branch.");
     if (project.link?.repo && project.link.org && !local.git.remote?.replace(/\.git$/u, "").endsWith(`${project.link.org}/${project.link.repo}`))
       fail("vercel_git_conflict", "The local origin repository differs from the Vercel Git connection.");
-    const env = z31.object({
-      envs: z31.array(z31.object({
-        key: z31.string(),
-        value: z31.string().optional(),
-        target: z31.array(z31.string()).optional()
+    const env = z32.object({
+      envs: z32.array(z32.object({
+        key: z32.string(),
+        value: z32.string().optional(),
+        target: z32.array(z32.string()).optional()
       }))
     }).parse(await setupVercelApi(linkDirectory, `/v10/projects/${linked.projectId}/env?teamId=${linked.orgId}`));
     const corepack = env.envs.some((item) => item.key === "ENABLE_EXPERIMENTAL_COREPACK" && item.value === "1" && item.target?.includes("production"));
@@ -2911,26 +2941,26 @@ function safeGitRemote(value) {
 }
 
 // ../cli/dist/commands/init.js
-var siteSetupBootstrapDataSchema = z32.object({
-  credentialPurpose: z32.literal("site_setup"),
-  apiBaseUrl: z32.string().url(),
-  siteId: z32.string().uuid(),
-  publicSiteKeyId: z32.string().uuid(),
-  publicSiteKey: z32.string().trim().min(1),
-  accessToken: z32.string().trim().min(1),
-  siteRevalidationSecret: z32.string().regex(/^[A-Za-z0-9_-]{43}$/u),
-  runId: z32.string().uuid(),
+var siteSetupBootstrapDataSchema = z33.object({
+  credentialPurpose: z33.literal("site_setup"),
+  apiBaseUrl: z33.string().url(),
+  siteId: z33.string().uuid(),
+  publicSiteKeyId: z33.string().uuid(),
+  publicSiteKey: z33.string().trim().min(1),
+  accessToken: z33.string().trim().min(1),
+  siteRevalidationSecret: z33.string().regex(/^[A-Za-z0-9_-]{43}$/u),
+  runId: z33.string().uuid(),
   packages: siteSetupPackagesSchema
 }).strict();
-var featureBootstrapDataSchema = z32.object({
-  credentialPurpose: z32.enum(["analytics", "booking"]),
-  apiBaseUrl: z32.string().url(),
-  siteId: z32.string().uuid(),
-  accessToken: z32.string().trim().min(1)
+var featureBootstrapDataSchema = z33.object({
+  credentialPurpose: z33.enum(["analytics", "booking"]),
+  apiBaseUrl: z33.string().url(),
+  siteId: z33.string().uuid(),
+  accessToken: z33.string().trim().min(1)
 }).strict();
-var bootstrapResponseSchema = z32.object({
-  ok: z32.literal(true),
-  data: z32.discriminatedUnion("credentialPurpose", [
+var bootstrapResponseSchema = z33.object({
+  ok: z33.literal(true),
+  data: z33.discriminatedUnion("credentialPurpose", [
     siteSetupBootstrapDataSchema,
     featureBootstrapDataSchema
   ])
@@ -2981,7 +3011,7 @@ async function collectSourceFiles(directory) {
 import { execFile as execFile2 } from "child_process";
 import { readFile as readFile9 } from "fs/promises";
 import { promisify as promisify2 } from "util";
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 
 // ../cli/dist/scan/next-source-scan.js
 import ts2 from "typescript";
@@ -3082,6 +3112,14 @@ function scanSourceFacts(files) {
   }
   for (const attr of directAttrs) {
     const field = fields.find((candidate) => candidate.fieldId === attr.fieldId);
+    if (field && attr.fieldType !== field.fieldType) {
+      warnings.push({
+        code: "field_scan.attrs_field_type_mismatch",
+        message: `DOM attrs for ${attr.fieldId} declare ${attr.fieldType}, but its value call returns ${field.fieldType}. Pass fieldType: "${field.fieldType}" with the matching routeKey to siteplane.attrs on the visible element. This affects editor preview, not the website build.`,
+        fieldId: attr.fieldId,
+        filePath: attr.filePath
+      });
+    }
     const expectedRoute = field?.technicalRouteKey ?? field?.routeHint;
     if (!attr.routeKey || expectedRoute && attr.routeKey !== expectedRoute) {
       hardErrors.push({
@@ -3363,6 +3401,7 @@ function collectAttrsCall(node, attrFieldIds, attrRouteRefs, eventPreviewAttrs,
     directAttrs.push({
       fieldId: directFieldId,
       routeKey: secondArg && typeof secondArg === "object" && "routeKey" in secondArg ? stringValue(secondArg.routeKey) : void 0,
+      fieldType: secondArg && typeof secondArg === "object" && "fieldType" in secondArg ? stringValue(secondArg.fieldType) ?? "text" : "text",
       filePath: file.filePath
     });
     if (hasEventPreviewStrategy(secondArg)) {
@@ -3669,32 +3708,32 @@ function isPositionalFieldReference(value) {
 
 // ../cli/dist/commands/site-setup.js
 var execFileAsync2 = promisify2(execFile2);
-var safeErrorSchema = z33.object({
-  code: z33.string().trim().min(1),
-  message: z33.string().trim().min(1)
+var safeErrorSchema = z34.object({
+  code: z34.string().trim().min(1),
+  message: z34.string().trim().min(1)
 }).passthrough();
-var errorResponseSchema2 = z33.object({ ok: z33.literal(false), error: safeErrorSchema }).passthrough();
-var contextDataSchema = z33.object({
+var errorResponseSchema2 = z34.object({ ok: z34.literal(false), error: safeErrorSchema }).passthrough();
+var contextDataSchema = z34.object({
   task: siteSetupTaskSchema.refine((task) => task.run !== null)
 }).strict();
-var contextResponseSchema = z33.object({ ok: z33.literal(true), data: contextDataSchema }).strict();
-var applyDataSchema = z33.object({
-  status: z33.enum(["applied", "ready_for_review"]),
-  runId: z33.string().uuid().optional(),
-  contractVersionId: z33.string().uuid().optional(),
-  fieldContractHash: z33.string().regex(/^sha256:[0-9a-f]{64}$/u),
-  editorDefinitionHash: z33.string().regex(/^sha256:[0-9a-f]{64}$/u).optional(),
-  fieldCount: z33.number().int().nonnegative().optional(),
-  routeCount: z33.number().int().nonnegative().optional()
+var contextResponseSchema = z34.object({ ok: z34.literal(true), data: contextDataSchema }).strict();
+var applyDataSchema = z34.object({
+  status: z34.enum(["applied", "ready_for_review"]),
+  runId: z34.string().uuid().optional(),
+  contractVersionId: z34.string().uuid().optional(),
+  fieldContractHash: z34.string().regex(/^sha256:[0-9a-f]{64}$/u),
+  editorDefinitionHash: z34.string().regex(/^sha256:[0-9a-f]{64}$/u).optional(),
+  fieldCount: z34.number().int().nonnegative().optional(),
+  routeCount: z34.number().int().nonnegative().optional()
 }).strict();
-var applyResponseSchema = z33.object({ ok: z33.literal(true), data: applyDataSchema }).strict();
-var verifyDataSchema = z33.object({
-  status: z33.literal("ready_for_review"),
-  runId: z33.string().uuid().optional(),
-  deploymentOrigin: z33.string().url().optional(),
-  deploymentRevision: z33.string().optional()
+var applyResponseSchema = z34.object({ ok: z34.literal(true), data: applyDataSchema }).strict();
+var verifyDataSchema = z34.object({
+  status: z34.literal("ready_for_review"),
+  runId: z34.string().uuid().optional(),
+  deploymentOrigin: z34.string().url().optional(),
+  deploymentRevision: z34.string().optional()
 }).strict();
-var verifyResponseSchema = z33.object({ ok: z33.literal(true), data: verifyDataSchema }).strict();
+var verifyResponseSchema = z34.object({ ok: z34.literal(true), data: verifyDataSchema }).strict();
 async function siteSetupContextCommand(input) {
   const response = await postSiteSetup(input, "context", {});
   const parsed = contextResponseSchema.safeParse(response.payload);
@@ -3787,42 +3826,52 @@ async function readGitRevision(projectDir) {
   return revision;
 }
 
+// ../cli/dist/commands/setup-start.js
+import { randomBytes, randomUUID as randomUUID4 } from "crypto";
+import { access as access4 } from "fs/promises";
+import { join as join9, relative as relative5 } from "path";
+import { z as z35 } from "zod";
+var bootstrapResponseSchema2 = z35.object({
+  ok: z35.literal(true),
+  data: siteSetupBootstrapDataSchema
+}).strict();
+
 // ../cli/dist/commands/setup-prepare.js
-import { access as access4, lstat as lstat2, mkdir as mkdir6, open as open3, readFile as readFile10, rename as rename3, rm as rm3 } from "fs/promises";
-import { randomUUID as randomUUID4 } from "crypto";
-import { dirname as dirname7, join as join9, relative as relative5, sep as sep2 } from "path";
+import { access as access5, lstat as lstat2, mkdir as mkdir6, open as open3, readFile as readFile10, rename as rename3, rm as rm3 } from "fs/promises";
+import { randomUUID as randomUUID5 } from "crypto";
+import { dirname as dirname7, join as join10, relative as relative6, sep as sep2 } from "path";
 import ts3 from "typescript";
 
 // ../cli/dist/commands/setup-lock.js
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 import { lstat as lstat3, mkdir as mkdir7, open as open4, readFile as readFile11, rm as rm4, rmdir } from "fs/promises";
 import { resolve as resolve2 } from "path";
-import { z as z34 } from "zod";
-var ownerSchema = z34.object({ pid: z34.number().int().positive(), nonce: z34.string().uuid() }).strict();
+import { z as z36 } from "zod";
+var ownerSchema = z36.object({ pid: z36.number().int().positive(), nonce: z36.string().uuid() }).strict();
 
 // ../cli/dist/config/build-provenance.js
 import { createHash as createHash3 } from "crypto";
 import { execFile as execFile3 } from "child_process";
 import { lstat as lstat4, readFile as readFile12, writeFile as writeFile5, mkdir as mkdir8 } from "fs/promises";
-import { dirname as dirname8, isAbsolute as isAbsolute2, join as join10, relative as relative6, resolve as resolve3, sep as sep3 } from "path";
+import { dirname as dirname8, isAbsolute as isAbsolute2, join as join11, relative as relative7, resolve as resolve3, sep as sep3 } from "path";
 import { isDeepStrictEqual, promisify as promisify3 } from "util";
-import { z as z35 } from "zod";
+import { z as z37 } from "zod";
 var execute = promisify3(execFile3);
 var name = ".siteplane/build-source.json";
-var oid = z35.string().regex(/^[0-9a-f]{40}$/u);
-var entrySchema = z35.object({
-  path: z35.string().min(1).max(4096),
-  mode: z35.enum(["100644", "100755", "120000"]),
+var oid = z37.string().regex(/^[0-9a-f]{40}$/u);
+var entrySchema = z37.object({
+  path: z37.string().min(1).max(4096),
+  mode: z37.enum(["100644", "100755", "120000"]),
   oid
 }).strict();
-var schema = z35.object({
-  version: z35.literal(2),
+var schema = z37.object({
+  version: z37.literal(2),
   revision: oid,
-  commit: z35.string().min(1).max(1048576),
-  entries: z35.array(entrySchema).min(1).max(1e5),
-  providerConfigurations: z35.array(z35.object({
-    path: z35.string().max(4096).regex(/(?:^|\/)vercel\.json$/u),
-    source: z35.string().max(1048576)
+  commit: z37.string().min(1).max(1048576),
+  entries: z37.array(entrySchema).min(1).max(1e5),
+  providerConfigurations: z37.array(z37.object({
+    path: z37.string().max(4096).regex(/(?:^|\/)vercel\.json$/u),
+    source: z37.string().max(1048576)
   }).strict()).max(1e3)
 }).strict();
 var gitHash = (type, content) => createHash3("sha1").update(`${type} ${content.length}\0`).update(content).digest("hex");
@@ -3845,15 +3894,15 @@ async function writeBuildProvenance(checkout, revision) {
     if (entry.mode !== "120000")
       continue;
     const { readlink: readlink2 } = await import("fs/promises");
-    const path = join10(checkout, entry.path);
+    const path = join11(checkout, entry.path);
     const target2 = resolve3(dirname8(path), await readlink2(path));
-    const bound = relative6(checkout, target2);
+    const bound = relative7(checkout, target2);
     if (bound.startsWith("..") || isAbsolute2(bound))
       throw new Error("A tracked symbolic link escapes the committed upload; resolve that source boundary before deployment.");
   }
   const providerConfigurations = await Promise.all(entries.filter((entry) => /(?:^|\/)vercel\.json$/u.test(entry.path)).map(async (entry) => ({
     path: entry.path,
-    source: await readFile12(join10(checkout, entry.path), "utf8")
+    source: await readFile12(join11(checkout, entry.path), "utf8")
   })));
   const record = schema.parse({
     version: 2,
@@ -3862,7 +3911,7 @@ async function writeBuildProvenance(checkout, revision) {
     entries,
     providerConfigurations
   });
-  const target = join10(checkout, name);
+  const target = join11(checkout, name);
   await mkdir8(dirname8(target), { recursive: true, mode: 448 });
   await writeFile5(target, JSON.stringify(record), { flag: "wx", mode: 384 });
 }
@@ -3870,7 +3919,7 @@ async function readBuildProvenance(projectDirectory) {
   let root = resolve3(projectDirectory);
   let raw = null;
   for (; ; ) {
-    raw = await readFile12(join10(root, name), "utf8").catch((error) => {
+    raw = await readFile12(join11(root, name), "utf8").catch((error) => {
       if (error.code === "ENOENT")
         return null;
       throw error;
@@ -3899,11 +3948,11 @@ async function readBuildProvenance(projectDirectory) {
   }
   if (record.entries.some((entry) => /(?:^|\/)vercel\.json$/u.test(entry.path) && !configurations.has(entry.path)))
     throw new Error("The committed provider configuration is missing from the build provenance.");
-  const appRelative = relative6(root, projectDirectory).split(sep3).join("/");
+  const appRelative = relative7(root, projectDirectory).split(sep3).join("/");
   if (!bound.has(appRelative ? `${appRelative}/package.json` : "package.json"))
     throw new Error("The selected app is not part of the committed upload.");
   for (const entry of record.entries) {
-    const path = join10(root, entry.path);
+    const path = join11(root, entry.path);
     const stat = await lstat4(path).catch((error) => {
       if (error.code === "ENOENT")
         return null;
@@ -3922,7 +3971,7 @@ async function readBuildProvenance(projectDirectory) {
       const original = configurations.get(entry.path);
       if (contents && original && entry.mode !== "120000") {
         try {
-          const object = z35.record(z35.string(), z35.unknown());
+          const object = z37.record(z37.string(), z37.unknown());
           const actual = object.parse(JSON.parse(contents.toString("utf8")));
           const expected = object.parse(JSON.parse(original));
           if (!Object.hasOwn(expected, "version") && actual.version === 2)
@@ -3972,42 +4021,42 @@ function treeHash(entries) {
 }
 
 // ../cli/dist/commands/setup-deploy.js
-import { createHash as createHash4, randomBytes, randomUUID as randomUUID6 } from "crypto";
-import { access as access5, mkdir as mkdir9, mkdtemp, rm as rm5, writeFile as writeFile6 } from "fs/promises";
+import { createHash as createHash4, randomBytes as randomBytes2, randomUUID as randomUUID7 } from "crypto";
+import { access as access6, mkdir as mkdir9, mkdtemp, rm as rm5, writeFile as writeFile6 } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join11 } from "path";
-import { z as z36 } from "zod";
-var envSchema = z36.object({
-  id: z36.string(),
-  key: z36.string(),
-  target: z36.array(z36.string()),
-  type: z36.string(),
-  comment: z36.string().optional(),
-  updatedAt: z36.number().optional()
+import { join as join12 } from "path";
+import { z as z38 } from "zod";
+var envSchema = z38.object({
+  id: z38.string(),
+  key: z38.string(),
+  target: z38.array(z38.string()),
+  type: z38.string(),
+  comment: z38.string().optional(),
+  updatedAt: z38.number().optional()
 });
-var deploymentSchema = z36.object({
-  id: z36.string(),
-  projectId: z36.string(),
-  ownerId: z36.string().optional(),
-  target: z36.string().nullable(),
-  readyState: z36.string(),
-  createdAt: z36.number(),
-  url: z36.string(),
-  meta: z36.record(z36.string(), z36.unknown()).optional(),
-  gitSource: z36.object({ sha: z36.string().optional() }).nullable().optional()
+var deploymentSchema = z38.object({
+  id: z38.string(),
+  projectId: z38.string(),
+  ownerId: z38.string().optional(),
+  target: z38.string().nullable(),
+  readyState: z38.string(),
+  createdAt: z38.number(),
+  url: z38.string(),
+  meta: z38.record(z38.string(), z38.unknown()).optional(),
+  gitSource: z38.object({ sha: z38.string().optional() }).nullable().optional()
 });
-var buildProofSchema = z36.object({
-  node: z36.string(),
-  packageManager: z36.enum(["npm", "pnpm"]),
-  packageManagerVersion: z36.string(),
-  lockfileHash: z36.string(),
-  revision: z36.string(),
-  fieldContractHash: z36.string(),
-  siteplane: z36.string(),
-  runtimeNext: z36.string(),
-  analytics: z36.string().optional(),
-  next: z36.string(),
-  react: z36.string()
+var buildProofSchema = z38.object({
+  node: z38.string(),
+  packageManager: z38.enum(["npm", "pnpm"]),
+  packageManagerVersion: z38.string(),
+  lockfileHash: z38.string(),
+  revision: z38.string(),
+  fieldContractHash: z38.string(),
+  siteplane: z38.string(),
+  runtimeNext: z38.string(),
+  analytics: z38.string().optional(),
+  next: z38.string(),
+  react: z38.string()
 }).strict();
 var defaults = {
   preflight: setupPreflightCommand,
@@ -4267,7 +4316,7 @@ async function emitBuildProof(projectDir, packages, revision, fieldContractHash)
   let lock = null;
   while (true) {
     lock = await readFile13(
-      join12(
+      join13(
         directory,
         packageManager === "npm" ? "package-lock.json" : "pnpm-lock.yaml"
       ),