siteplane 0.1.51 → 0.1.53

package/dist/next.js

@@ -1865,6 +1865,18 @@ var fieldBridgeIdentitySchema = z17.object({
   fieldContractHash: canonicalFieldContractHashSchema,
   deploymentRevision: z17.string().trim().min(1).max(256)
 }).strict();
+var setupPreviewAccessSchema = z17.object({
+  capability: z17.string().regex(/^v1\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]{43}$/u).max(4096),
+  expiresAt: z17.string().datetime()
+}).strict();
+var setupPreviewReadSchema = fieldBridgeIdentitySchema.extend({
+  scope: z17.literal("setup_preview"),
+  siteId: z17.string().uuid(),
+  runId: z17.string().uuid(),
+  bridgeSessionId: z17.string().min(1),
+  expiresAt: z17.string().datetime(),
+  contract: siteFieldContractV1Schema
+}).strict();
 var fieldBridgeBaseSchema = z17.object({
   version: z17.literal(BRIDGE_PROTOCOL_VERSION),
   type: z17.enum(FIELD_BRIDGE_MESSAGE_TYPES),
@@ -1892,7 +1904,8 @@ var fieldBridgeInitMessageSchema = fieldBridgeBaseSchema.extend({
   payload: z17.object({
     adminOrigin: z17.string().url(),
     customerOrigin: z17.string().url(),
-    renderedPath: realRenderedPathSchema
+    renderedPath: realRenderedPathSchema,
+    setupPreview: setupPreviewAccessSchema.optional()
   }).strict()
 });
 var fieldBridgeReadyMessageSchema = fieldBridgeBaseSchema.extend({
@@ -1905,7 +1918,7 @@ var fieldBridgeReadyMessageSchema = fieldBridgeBaseSchema.extend({
       z17.literal("preview_values"),
       z17.literal("field_evidence"),
       z17.literal("visual_field_control")
-    ]).rest(z17.literal("analytics_preview_readiness")).refine((capabilities) => capabilities.length <= 5)
+    ]).rest(z17.enum(["analytics_preview_readiness", "setup_preview"])).refine((capabilities) => capabilities.length <= 6)
   }).strict()
 });
 var fieldBridgeFieldsMessageSchema = fieldBridgeBaseSchema.extend({
@@ -2248,6 +2261,47 @@ var setupInstallationRequestSchema = z26.object({
   }).strict()
 }).strict();
 
+// ../shared/dist/setup-claim.js
+import { z as z27 } from "zod";
+var setupClaimCodeSchema = z27.string().regex(/^[0-9A-HJKMNP-TV-Z]{8}$/u);
+var setupClaimBindingSchema = z27.object({
+  siteId: z27.string().uuid(),
+  runId: z27.string().uuid()
+});
+var setupClaimReceiptSchema = setupClaimBindingSchema.extend({
+  status: z27.literal("claimed"),
+  requestId: z27.string().uuid(),
+  workspaceId: z27.string().uuid(),
+  userId: z27.string().uuid(),
+  claimedAt: z27.string().datetime({ offset: true })
+}).strict();
+var setupClaimInspectionSchema = setupClaimBindingSchema.extend({
+  status: z27.literal("pending"),
+  requestId: z27.string().uuid(),
+  siteName: z27.string(),
+  userId: z27.string().uuid(),
+  accountEmail: z27.string().email(),
+  workspaceId: z27.string().uuid(),
+  workspaceName: z27.string(),
+  expiresAt: z27.string().datetime({ offset: true })
+}).strict();
+var setupClaimDenialSchema = z27.object({
+  status: z27.enum([
+    "invalid_claim_request",
+    "invalid_installation",
+    "already_claimed",
+    "project_expired",
+    "invalid_guest_session",
+    "stale_setup_review",
+    "verified_account_required",
+    "workspace_access_denied",
+    "workspace_entitlement_required",
+    "site_limit_reached",
+    "provisional_relationship_conflict",
+    "rate_limited"
+  ])
+}).strict();
+
 // ../cli/dist/analytics/static-scan.js
 import ts from "typescript";
 
@@ -2300,16 +2354,16 @@ function createAnalyticsCliRequestHeaders(config) {
 }
 
 // ../cli/dist/commands/analytics/public-key.js
-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}$/)
+import { z as z28 } from "zod";
+var responseSchema = 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}$/)
   })
 });
-var errorResponseSchema = z27.object({
-  error: z27.object({
-    code: z27.string().regex(/^[a-z][a-z0-9_.-]+$/u)
+var errorResponseSchema = z28.object({
+  error: z28.object({
+    code: z28.string().regex(/^[a-z][a-z0-9_.-]+$/u)
   })
 });
 async function analyticsPublicKeyCommand(input) {
@@ -2331,13 +2385,13 @@ async function analyticsPublicKeyCommand(input) {
 }
 
 // ../cli/dist/commands/analytics/prepare.js
-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([
+import { z as z29 } from "zod";
+var resultSchema = z29.object({
+  ok: z29.literal(true),
+  data: z29.object({
+    rawPublicKey: z29.string().regex(/^pk_siteplane_[A-Za-z0-9_-]{16}_[A-Za-z0-9_-]{43}$/u),
+    generation: z29.number().int().positive(),
+    status: z29.enum([
       "setup_started",
       "test_mode",
       "active",
@@ -2347,8 +2401,8 @@ var resultSchema = z28.object({
     ])
   }).strict()
 }).strict();
-var errorSchema = z28.object({
-  error: z28.object({ code: z28.string().regex(/^[a-z][a-z0-9_.-]+$/u) })
+var errorSchema = z29.object({
+  error: z29.object({ code: z29.string().regex(/^[a-z][a-z0-9_.-]+$/u) })
 });
 
 // ../cli/dist/commands/analytics/test.js
@@ -2381,19 +2435,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 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),
+import { z as z30 } from "zod";
+var siteplaneProjectConfigSchema = z30.object({
+  version: z30.literal(2),
+  apiBaseUrl: z30.string().url(),
+  siteId: z30.string().uuid(),
+  publicSiteKeyId: z30.string().uuid(),
+  publicSiteKey: z30.string().trim().min(1),
+  runId: z30.string().uuid(),
+  appDirectory: z30.string().min(1),
+  taskContractVersion: z30.literal("siteplane.setup-task.v2"),
+  adminProtocolVersion: z30.literal(2),
   packages: siteSetupPackagesSchema,
-  fieldContractHash: z29.string().regex(/^sha256:[0-9a-f]{64}$/iu).optional()
+  fieldContractHash: z30.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")));
@@ -2405,26 +2459,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 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(),
+import { z as z31 } from "zod";
+var localSetupInstallationSchema = z31.object({
+  key: z31.string().regex(/^[A-Za-z0-9_-]{43}$/u),
+  idempotencyKey: z31.string().uuid(),
+  apiBaseUrl: z31.string().url(),
   request: setupInstallationRequestSchema,
-  bootstrapAcknowledged: z30.boolean()
+  bootstrapAcknowledged: z31.boolean()
 }).strict();
-var siteplaneCredentialsSchema = z30.object({
-  accessToken: z30.string().trim().min(1),
-  siteRevalidationSecret: z30.string().trim().min(1),
+var siteplaneCredentialsSchema = z31.object({
+  accessToken: z31.string().trim().min(1),
+  siteRevalidationSecret: z31.string().trim().min(1),
   installation: localSetupInstallationSchema.optional(),
-  adminSession: z30.object({
-    secret: z30.string().regex(/^[A-Za-z0-9_-]{43}$/u),
-    generation: z30.string().uuid()
+  claimReceipt: setupClaimReceiptSchema.optional(),
+  adminSession: z31.object({
+    secret: z31.string().regex(/^[A-Za-z0-9_-]{43}$/u),
+    generation: z31.string().uuid()
   }).strict().optional()
 }).strict();
-var localSetupCredentialsSchema = z30.union([
+var localSetupCredentialsSchema = z31.union([
   siteplaneCredentialsSchema,
-  z30.object({ installation: localSetupInstallationSchema }).strict()
+  z31.object({ installation: localSetupInstallationSchema }).strict()
 ]);
 async function assertLocalCredentialsPathSafe(projectDir, options = {}) {
   const path = join4(projectDir, ".siteplane/credentials.json");
@@ -2485,7 +2540,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 z33 } from "zod";
+import { z as z34 } from "zod";
 
 // ../cli/dist/commands/setup-preflight.js
 import { createHash as createHash2 } from "crypto";
@@ -2497,11 +2552,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 z31 } from "zod";
-var packageSchema = z31.object({
-  name: z31.string().optional(),
-  version: z31.string(),
-  peerDependencies: z31.record(z31.string(), z31.string()).optional()
+import { z as z32 } from "zod";
+var packageSchema = z32.object({
+  name: z32.string().optional(),
+  version: z32.string(),
+  peerDependencies: z32.record(z32.string(), z32.string()).optional()
 });
 async function readInstalledPackage(projectDir, name2) {
   const require2 = createRequire(join5(projectDir, "package.json"));
@@ -2519,7 +2574,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 z32 } from "zod";
+import { z as z33 } from "zod";
 
 // ../cli/dist/commands/setup-process.js
 import { spawn } from "child_process";
@@ -2620,29 +2675,29 @@ async function setupVercelApi(cwd, endpoint, body, method, options) {
 }
 
 // ../cli/dist/commands/setup-preflight.js
-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 manifestSchema = z33.object({
+  packageManager: z33.string().optional(),
+  engines: z33.object({ node: z33.string().optional() }).optional(),
+  dependencies: z33.record(z33.string(), z33.string()).optional(),
+  devDependencies: z33.record(z33.string(), z33.string()).optional(),
+  scripts: z33.record(z33.string(), z33.string()).optional(),
+  workspaces: z33.unknown().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()
+var vercelProjectSchema = z33.object({
+  id: z33.string(),
+  accountId: z33.string(),
+  name: z33.string(),
+  nodeVersion: z33.string().nullable().optional(),
+  rootDirectory: z33.string().nullable().optional(),
+  framework: z33.string().nullable().optional(),
+  installCommand: z33.string().nullable().optional(),
+  buildCommand: z33.string().nullable().optional(),
+  link: z33.object({
+    type: z33.string(),
+    repo: z33.string().optional(),
+    repoId: z33.union([z33.string(), z33.number()]).optional(),
+    org: z33.string().optional(),
+    productionBranch: z33.string().optional()
   }).nullable().optional()
 });
 var exists = async (path) => access2(path).then(() => true, () => false);
@@ -2699,9 +2754,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) ? 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)
+    const workspace = lockName === "pnpm-lock.yaml" && await exists(workspaceFile) ? z33.object({ packages: z33.array(z33.string()) }).parse(parseYaml(await readFile8(workspaceFile, "utf8"))).packages : z33.union([
+      z33.array(z33.string()),
+      z33.object({ packages: z33.array(z33.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))))
@@ -2715,11 +2770,11 @@ async function inspectSetupLocalProject(projectDir) {
       break;
   }
   const lockText = await readFile8(join6(lockfileRoot, lockName), "utf8");
-  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()
+  const npmLock = lockName === "package-lock.json" ? z33.object({
+    lockfileVersion: z33.number(),
+    packages: z33.record(z33.string(), z33.object({
+      version: z33.string().optional(),
+      peerDependencies: z33.record(z33.string(), z33.string()).optional()
     })).optional()
   }).parse(JSON.parse(lockText)) : null;
   async function version2(name3) {
@@ -2859,9 +2914,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 = z32.object({
-      projectId: z32.string().regex(/^prj_[A-Za-z0-9]+$/u),
-      orgId: z32.string().regex(/^(?:team|user)_[A-Za-z0-9]+$/u)
+    const linked = z33.object({
+      projectId: z33.string().regex(/^prj_[A-Za-z0-9]+$/u),
+      orgId: z33.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)
@@ -2875,11 +2930,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 = z32.object({
-      envs: z32.array(z32.object({
-        key: z32.string(),
-        value: z32.string().optional(),
-        target: z32.array(z32.string()).optional()
+    const env = z33.object({
+      envs: z33.array(z33.object({
+        key: z33.string(),
+        value: z33.string().optional(),
+        target: z33.array(z33.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"));
@@ -2941,26 +2996,26 @@ function safeGitRemote(value) {
 }
 
 // ../cli/dist/commands/init.js
-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(),
+var siteSetupBootstrapDataSchema = z34.object({
+  credentialPurpose: z34.literal("site_setup"),
+  apiBaseUrl: z34.string().url(),
+  siteId: z34.string().uuid(),
+  publicSiteKeyId: z34.string().uuid(),
+  publicSiteKey: z34.string().trim().min(1),
+  accessToken: z34.string().trim().min(1),
+  siteRevalidationSecret: z34.string().regex(/^[A-Za-z0-9_-]{43}$/u),
+  runId: z34.string().uuid(),
   packages: siteSetupPackagesSchema
 }).strict();
-var featureBootstrapDataSchema = z33.object({
-  credentialPurpose: z33.enum(["analytics", "booking"]),
-  apiBaseUrl: z33.string().url(),
-  siteId: z33.string().uuid(),
-  accessToken: z33.string().trim().min(1)
+var featureBootstrapDataSchema = z34.object({
+  credentialPurpose: z34.enum(["analytics", "booking"]),
+  apiBaseUrl: z34.string().url(),
+  siteId: z34.string().uuid(),
+  accessToken: z34.string().trim().min(1)
 }).strict();
-var bootstrapResponseSchema = z33.object({
-  ok: z33.literal(true),
-  data: z33.discriminatedUnion("credentialPurpose", [
+var bootstrapResponseSchema = z34.object({
+  ok: z34.literal(true),
+  data: z34.discriminatedUnion("credentialPurpose", [
     siteSetupBootstrapDataSchema,
     featureBootstrapDataSchema
   ])
@@ -3011,7 +3066,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 z34 } from "zod";
+import { z as z35 } from "zod";
 
 // ../cli/dist/scan/next-source-scan.js
 import ts2 from "typescript";
@@ -3708,32 +3763,32 @@ function isPositionalFieldReference(value) {
 
 // ../cli/dist/commands/site-setup.js
 var execFileAsync2 = promisify2(execFile2);
-var safeErrorSchema = z34.object({
-  code: z34.string().trim().min(1),
-  message: z34.string().trim().min(1)
+var safeErrorSchema = z35.object({
+  code: z35.string().trim().min(1),
+  message: z35.string().trim().min(1)
 }).passthrough();
-var errorResponseSchema2 = z34.object({ ok: z34.literal(false), error: safeErrorSchema }).passthrough();
-var contextDataSchema = z34.object({
+var errorResponseSchema2 = z35.object({ ok: z35.literal(false), error: safeErrorSchema }).passthrough();
+var contextDataSchema = z35.object({
   task: siteSetupTaskSchema.refine((task) => task.run !== null)
 }).strict();
-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()
+var contextResponseSchema = z35.object({ ok: z35.literal(true), data: contextDataSchema }).strict();
+var applyDataSchema = z35.object({
+  status: z35.enum(["applied", "ready_for_review"]),
+  runId: z35.string().uuid().optional(),
+  contractVersionId: z35.string().uuid().optional(),
+  fieldContractHash: z35.string().regex(/^sha256:[0-9a-f]{64}$/u),
+  editorDefinitionHash: z35.string().regex(/^sha256:[0-9a-f]{64}$/u).optional(),
+  fieldCount: z35.number().int().nonnegative().optional(),
+  routeCount: z35.number().int().nonnegative().optional()
 }).strict();
-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()
+var applyResponseSchema = z35.object({ ok: z35.literal(true), data: applyDataSchema }).strict();
+var verifyDataSchema = z35.object({
+  status: z35.literal("ready_for_review"),
+  runId: z35.string().uuid().optional(),
+  deploymentOrigin: z35.string().url().optional(),
+  deploymentRevision: z35.string().optional()
 }).strict();
-var verifyResponseSchema = z34.object({ ok: z34.literal(true), data: verifyDataSchema }).strict();
+var verifyResponseSchema = z35.object({ ok: z35.literal(true), data: verifyDataSchema }).strict();
 async function siteSetupContextCommand(input) {
   const response = await postSiteSetup(input, "context", {});
   const parsed = contextResponseSchema.safeParse(response.payload);
@@ -3830,12 +3885,22 @@ async function readGitRevision(projectDir) {
 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),
+import { z as z36 } from "zod";
+var bootstrapResponseSchema2 = z36.object({
+  ok: z36.literal(true),
   data: siteSetupBootstrapDataSchema
 }).strict();
 
+// ../cli/dist/commands/setup-review.js
+import { z as z37 } from "zod";
+var responseSchema2 = z37.object({
+  ok: z37.literal(true),
+  data: z37.object({
+    reviewUrl: z37.string().url(),
+    expiresAt: z37.string().datetime({ offset: true })
+  }).strict()
+}).strict();
+
 // ../cli/dist/commands/setup-prepare.js
 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";
@@ -3846,8 +3911,8 @@ import ts3 from "typescript";
 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 z36 } from "zod";
-var ownerSchema = z36.object({ pid: z36.number().int().positive(), nonce: z36.string().uuid() }).strict();
+import { z as z38 } from "zod";
+var ownerSchema = z38.object({ pid: z38.number().int().positive(), nonce: z38.string().uuid() }).strict();
 
 // ../cli/dist/config/build-provenance.js
 import { createHash as createHash3 } from "crypto";
@@ -3855,23 +3920,23 @@ 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 join11, relative as relative7, resolve as resolve3, sep as sep3 } from "path";
 import { isDeepStrictEqual, promisify as promisify3 } from "util";
-import { z as z37 } from "zod";
+import { z as z39 } from "zod";
 var execute = promisify3(execFile3);
 var name = ".siteplane/build-source.json";
-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"]),
+var oid = z39.string().regex(/^[0-9a-f]{40}$/u);
+var entrySchema = z39.object({
+  path: z39.string().min(1).max(4096),
+  mode: z39.enum(["100644", "100755", "120000"]),
   oid
 }).strict();
-var schema = z37.object({
-  version: z37.literal(2),
+var schema = z39.object({
+  version: z39.literal(2),
   revision: oid,
-  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)
+  commit: z39.string().min(1).max(1048576),
+  entries: z39.array(entrySchema).min(1).max(1e5),
+  providerConfigurations: z39.array(z39.object({
+    path: z39.string().max(4096).regex(/(?:^|\/)vercel\.json$/u),
+    source: z39.string().max(1048576)
   }).strict()).max(1e3)
 }).strict();
 var gitHash = (type, content) => createHash3("sha1").update(`${type} ${content.length}\0`).update(content).digest("hex");
@@ -3971,7 +4036,7 @@ async function readBuildProvenance(projectDirectory) {
       const original = configurations.get(entry.path);
       if (contents && original && entry.mode !== "120000") {
         try {
-          const object = z37.record(z37.string(), z37.unknown());
+          const object = z39.record(z39.string(), z39.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)
@@ -4025,38 +4090,38 @@ import { createHash as createHash4, randomBytes as randomBytes2, randomUUID as r
 import { access as access6, mkdir as mkdir9, mkdtemp, rm as rm5, writeFile as writeFile6 } from "fs/promises";
 import { tmpdir } from "os";
 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()
+import { z as z40 } from "zod";
+var envSchema = z40.object({
+  id: z40.string(),
+  key: z40.string(),
+  target: z40.array(z40.string()),
+  type: z40.string(),
+  comment: z40.string().optional(),
+  updatedAt: z40.number().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 deploymentSchema = z40.object({
+  id: z40.string(),
+  projectId: z40.string(),
+  ownerId: z40.string().optional(),
+  target: z40.string().nullable(),
+  readyState: z40.string(),
+  createdAt: z40.number(),
+  url: z40.string(),
+  meta: z40.record(z40.string(), z40.unknown()).optional(),
+  gitSource: z40.object({ sha: z40.string().optional() }).nullable().optional()
 });
-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()
+var buildProofSchema = z40.object({
+  node: z40.string(),
+  packageManager: z40.enum(["npm", "pnpm"]),
+  packageManagerVersion: z40.string(),
+  lockfileHash: z40.string(),
+  revision: z40.string(),
+  fieldContractHash: z40.string(),
+  siteplane: z40.string(),
+  runtimeNext: z40.string(),
+  analytics: z40.string().optional(),
+  next: z40.string(),
+  react: z40.string()
 }).strict();
 var defaults = {
   preflight: setupPreflightCommand,
@@ -4071,6 +4136,9 @@ var defaults = {
   pause: (milliseconds) => new Promise((resolve5) => setTimeout(resolve5, milliseconds))
 };
 
+// ../cli/dist/commands/setup-claim.js
+import { z as z41 } from "zod";
+
 // src/next.ts
 var SiteplaneNextContractError = class extends Error {
   constructor(code, message) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "siteplane",
   "private": false,
-  "version": "0.1.51",
+  "version": "0.1.53",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",
   "publishConfig": {