siteplane 0.1.36 → 0.1.38

package/dist/index.js

@@ -4,7 +4,7 @@ import { dirname } from "path";
 
 // ../shared/dist/actors.js
 import { z } from "zod";
-var ACTOR_TYPES = ["developer", "client", "agent", "system"];
+var ACTOR_TYPES = ["workspace_member", "site_member", "agent", "system"];
 var actorTypeSchema = z.enum(ACTOR_TYPES);
 
 // ../shared/dist/analytics-defaults.js
@@ -587,7 +587,7 @@ var bookingAvailabilityIntervalsSchema = z8.array(z8.object({
 });
 var bookingPublicConfigSchema = z8.object({
   site: z8.object({
-    name: z8.string().trim().min(1),
+    displayName: z8.string().trim().min(1),
     timezone: z8.string().trim().min(1),
     locale: z8.string().trim().min(2),
     bookingPageSlug: z8.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).min(2).max(64),
@@ -1011,6 +1011,9 @@ var CONTINUE_SITE_SETUP_MAX_ITEMS = 50;
 var CONTINUE_SITE_SETUP_RENDERED_PATH_MAX_BYTES = 512;
 var CONTINUE_SITE_SETUP_VISIBLE_VALUE_MAX_BYTES = 256;
 var CONTINUE_SITE_SETUP_LOCATOR_HINT_MAX_BYTES = 512;
+var CONTINUE_SITE_SETUP_REQUESTED_LABEL_MAX_BYTES = 120;
+var CONTINUE_SITE_SETUP_REQUESTED_SECTION_MAX_BYTES = 120;
+var CONTINUE_SITE_SETUP_REQUESTED_SUBSECTION_MAX_BYTES = 120;
 var CONTINUE_SITE_SETUP_ITEMS_MAX_BYTES = 32 * 1024;
 var CONTINUE_SITE_SETUP_HTTP_BODY_MAX_BYTES = 64 * 1024;
 var siteSetupRunStatusSchema = z14.enum(SITE_SETUP_RUN_STATUSES);
@@ -1019,6 +1022,7 @@ var siteSetupErrorCodeSchema = z14.enum(SITE_SETUP_ERROR_CODES);
 var editorFieldSchema = z14.object({
   fieldId: fieldIdSchema,
   label: z14.string().trim().min(1),
+  subsection: z14.string().trim().min(1).optional(),
   description: z14.string().trim().min(1).optional(),
   required: z14.boolean().optional(),
   maxLength: z14.number().int().positive().optional()
@@ -1026,7 +1030,24 @@ var editorFieldSchema = z14.object({
 var editorSectionSchema = z14.object({
   label: z14.string().trim().min(1),
   fields: z14.array(editorFieldSchema).min(1)
-}).strict();
+}).strict().superRefine((section, context) => {
+  const closedSubsections = /* @__PURE__ */ new Set();
+  let currentSubsection;
+  for (const [index, field] of section.fields.entries()) {
+    if (field.subsection === currentSubsection)
+      continue;
+    if (currentSubsection)
+      closedSubsections.add(currentSubsection);
+    currentSubsection = field.subsection;
+    if (currentSubsection && closedSubsections.has(currentSubsection)) {
+      context.addIssue({
+        code: "custom",
+        message: `Subgroup fields must stay contiguous: ${currentSubsection}`,
+        path: ["fields", index, "subsection"]
+      });
+    }
+  }
+});
 var editorRouteSchema = z14.object({
   routeKey: siteFieldRouteKeySchema,
   label: z14.string().trim().min(1),
@@ -1106,13 +1127,34 @@ function normalizedSafeTextSchema(maxBytes, label) {
 var correctionItemBase = {
   renderedPath: renderedPathSchema,
   visibleValue: normalizedSafeTextSchema(CONTINUE_SITE_SETUP_VISIBLE_VALUE_MAX_BYTES, "visibleValue"),
-  locatorHint: normalizedSafeTextSchema(CONTINUE_SITE_SETUP_LOCATOR_HINT_MAX_BYTES, "locatorHint")
+  locatorHint: normalizedSafeTextSchema(CONTINUE_SITE_SETUP_LOCATOR_HINT_MAX_BYTES, "locatorHint"),
+  requestedLabel: normalizedSafeTextSchema(CONTINUE_SITE_SETUP_REQUESTED_LABEL_MAX_BYTES, "requestedLabel").optional(),
+  requestedSection: normalizedSafeTextSchema(CONTINUE_SITE_SETUP_REQUESTED_SECTION_MAX_BYTES, "requestedSection").optional(),
+  requestedSubsection: normalizedSafeTextSchema(CONTINUE_SITE_SETUP_REQUESTED_SUBSECTION_MAX_BYTES, "requestedSubsection").optional(),
+  requestedSortOrder: z14.number().int().nonnegative().optional()
 };
 var setupCorrectionItemSchema = z14.discriminatedUnion("kind", [
   z14.object({ kind: z14.literal("text"), ...correctionItemBase }).strict(),
   z14.object({ kind: z14.literal("link"), ...correctionItemBase }).strict(),
   z14.object({ kind: z14.literal("image"), ...correctionItemBase }).strict()
-]);
+]).superRefine((item, context) => {
+  if (item.requestedSubsection && !item.requestedSection) {
+    context.addIssue({
+      code: "custom",
+      message: "requestedSubsection requires requestedSection.",
+      path: ["requestedSubsection"]
+    });
+  }
+});
+var setupCorrectionItemsSchema = z14.array(setupCorrectionItemSchema).max(CONTINUE_SITE_SETUP_MAX_ITEMS).superRefine((items, context) => {
+  const bytes = utf8Bytes(stableJsonStringify(items));
+  if (bytes > CONTINUE_SITE_SETUP_ITEMS_MAX_BYTES) {
+    context.addIssue({
+      code: "custom",
+      message: "Correction items exceed the 32 KiB canonical payload limit."
+    });
+  }
+});
 var canonicalHashSchema = z14.string().regex(/^sha256:[0-9a-f]{64}$/iu);
 var deploymentRevisionSchema = normalizedSafeTextSchema(256, "deploymentRevision");
 var continueSiteSetupInputSchema = z14.object({
@@ -1120,17 +1162,8 @@ var continueSiteSetupInputSchema = z14.object({
   runId: z14.string().uuid(),
   expectedFieldContractHash: canonicalHashSchema,
   expectedDeploymentRevision: deploymentRevisionSchema,
-  correctionItems: z14.array(setupCorrectionItemSchema).max(CONTINUE_SITE_SETUP_MAX_ITEMS)
-}).strict().superRefine((input, context) => {
-  const bytes = utf8Bytes(stableJsonStringify(input.correctionItems));
-  if (bytes > CONTINUE_SITE_SETUP_ITEMS_MAX_BYTES) {
-    context.addIssue({
-      code: "custom",
-      message: "Correction items exceed the 32 KiB canonical payload limit.",
-      path: ["correctionItems"]
-    });
-  }
-});
+  correctionItems: setupCorrectionItemsSchema
+}).strict();
 var siteSetupContextInputSchema = z14.object({}).strict();
 var siteSetupApplyInputSchema = z14.object({
   fieldContract: siteFieldContractV1Schema,
@@ -1224,25 +1257,8 @@ var completeSiteSetupInputSchema = z14.object({
   runId: z14.string().uuid(),
   expectedFieldContractHash: canonicalHashSchema,
   expectedDeploymentRevision: deploymentRevisionSchema,
-  accessMode: z14.enum(["fallback", "custom_domain"]),
-  siteDomainId: z14.string().uuid().optional(),
-  defaultCanPublish: z14.boolean()
-}).strict().superRefine((input, context) => {
-  if (input.accessMode === "fallback" && input.siteDomainId) {
-    context.addIssue({
-      code: "custom",
-      message: "Fallback access cannot use a custom domain.",
-      path: ["siteDomainId"]
-    });
-  }
-  if (input.accessMode === "custom_domain" && !input.siteDomainId) {
-    context.addIssue({
-      code: "custom",
-      message: "Custom-domain access requires a site domain.",
-      path: ["siteDomainId"]
-    });
-  }
-});
+  expectedReadyFingerprint: canonicalHashSchema
+}).strict();
 var refreshSiteSetupDeploymentInputSchema = z14.object({
   siteId: z14.string().uuid(),
   deploymentUrl: z14.string().url().refine((value) => value.startsWith("https://")),
@@ -1267,7 +1283,7 @@ function utf8Bytes(value) {
 }
 
 // ../shared/dist/bridge-protocol.js
-var BRIDGE_PROTOCOL_VERSION = 1;
+var BRIDGE_PROTOCOL_VERSION = 2;
 var bridgeRectSchema = z15.object({
   x: z15.number(),
   y: z15.number(),
@@ -1294,6 +1310,12 @@ var bridgePreviewValueSchema = z15.discriminatedUnion("fieldType", [
   previewLinkValueSchema,
   previewImageValueSchema
 ]);
+var fieldSelectionModeSchema = z15.enum(["replace", "range", "toggle"]);
+var fieldBridgeMissingContentActionSchema = z15.enum([
+  "add",
+  "select",
+  "remove"
+]);
 var FIELD_BRIDGE_MESSAGE_TYPES = [
   "siteplane:field-bridge:init",
   "siteplane:field-bridge:ready",
@@ -1303,11 +1325,12 @@ var FIELD_BRIDGE_MESSAGE_TYPES = [
   "siteplane:field-bridge:apply-preview-values",
   "siteplane:field-bridge:test-preview-values",
   "siteplane:field-bridge:preview-ack",
-  "siteplane:field-bridge:set-editability-review",
+  "siteplane:field-bridge:set-visual-control-state",
   "siteplane:field-bridge:missing-content",
   "siteplane:field-bridge:error"
 ];
 var canonicalFieldContractHashSchema = z15.string().regex(/^sha256:[0-9a-f]{64}$/u);
+var bridgeSectionSchema = z15.string().trim().min(1).max(256);
 var realRenderedPathSchema = z15.string().trim().refine((value) => value.startsWith("/") && value !== "$global" && !value.includes("?") && !value.includes("#"), "A field bridge rendered path must be a real canonical path.");
 var fieldBridgeIdentitySchema = z15.object({
   publicRuntimeKeyId: z15.string().uuid(),
@@ -1353,7 +1376,7 @@ var fieldBridgeReadyMessageSchema = fieldBridgeBaseSchema.extend({
       z15.literal("field_selection"),
       z15.literal("preview_values"),
       z15.literal("field_evidence"),
-      z15.literal("editability_review")
+      z15.literal("visual_field_control")
     ])
   }).strict()
 });
@@ -1366,14 +1389,33 @@ var fieldBridgeFieldsMessageSchema = fieldBridgeBaseSchema.extend({
 });
 var fieldBridgeSelectFieldMessageSchema = fieldBridgeBaseSchema.extend({
   type: z15.literal("siteplane:field-bridge:select-field"),
-  payload: z15.object({ fieldId: fieldIdSchema }).strict()
+  payload: z15.object({
+    fieldId: fieldIdSchema,
+    selectionMode: fieldSelectionModeSchema
+  }).strict()
 });
 var fieldBridgeSetSelectedFieldMessageSchema = fieldBridgeBaseSchema.extend({
   type: z15.literal("siteplane:field-bridge:set-selected-field"),
   payload: z15.object({
-    fieldId: fieldIdSchema.nullable(),
+    fieldIds: z15.array(fieldIdSchema).max(200),
+    primaryFieldId: fieldIdSchema.nullable(),
     scrollIntoView: z15.boolean().optional()
-  }).strict()
+  }).strict().superRefine((value, context) => {
+    if (value.fieldIds.length > 0 && value.primaryFieldId === null) {
+      context.addIssue({
+        code: "custom",
+        message: "A non-empty selection needs a primary field.",
+        path: ["primaryFieldId"]
+      });
+    }
+    if (value.primaryFieldId !== null && !value.fieldIds.includes(value.primaryFieldId)) {
+      context.addIssue({
+        code: "custom",
+        message: "The primary field must be part of the selection.",
+        path: ["primaryFieldId"]
+      });
+    }
+  })
 });
 var fieldBridgeApplyPreviewValuesMessageSchema = fieldBridgeBaseSchema.extend({
   type: z15.literal("siteplane:field-bridge:apply-preview-values"),
@@ -1392,13 +1434,28 @@ var fieldBridgePreviewAckMessageSchema = fieldBridgeBaseSchema.extend({
     fieldIds: z15.array(fieldIdSchema).max(200)
   }).strict()
 });
-var fieldBridgeSetEditabilityReviewMessageSchema = fieldBridgeBaseSchema.extend({
-  type: z15.literal("siteplane:field-bridge:set-editability-review"),
-  payload: z15.object({ enabled: z15.boolean() }).strict()
+var fieldBridgeSetVisualControlStateMessageSchema = fieldBridgeBaseSchema.extend({
+  type: z15.literal("siteplane:field-bridge:set-visual-control-state"),
+  payload: z15.object({
+    enabled: z15.boolean(),
+    fieldProximityEnabled: z15.boolean(),
+    pendingKeys: z15.array(z15.string().trim().min(1).max(2048)).max(50),
+    activeFieldIds: z15.array(fieldIdSchema),
+    fieldSections: z15.record(fieldIdSchema, bridgeSectionSchema),
+    selectedPending: z15.array(z15.object({
+      key: z15.string().trim().min(1).max(2048),
+      locatorHint: z15.string().trim().min(1).max(2048)
+    }).strict()).max(50),
+    scrollPendingIntoView: z15.boolean().optional()
+  }).strict()
 });
 var fieldBridgeMissingContentMessageSchema = fieldBridgeBaseSchema.extend({
   type: z15.literal("siteplane:field-bridge:missing-content"),
-  payload: z15.object({ item: setupCorrectionItemSchema }).strict()
+  payload: z15.object({
+    action: fieldBridgeMissingContentActionSchema,
+    item: setupCorrectionItemSchema,
+    suggestedSection: bridgeSectionSchema.optional()
+  }).strict()
 });
 var fieldBridgeErrorMessageSchema = fieldBridgeBaseSchema.extend({
   type: z15.literal("siteplane:field-bridge:error"),
@@ -1417,7 +1474,7 @@ var fieldBridgeMessageSchema = z15.discriminatedUnion("type", [
   fieldBridgeApplyPreviewValuesMessageSchema,
   fieldBridgeTestPreviewValuesMessageSchema,
   fieldBridgePreviewAckMessageSchema,
-  fieldBridgeSetEditabilityReviewMessageSchema,
+  fieldBridgeSetVisualControlStateMessageSchema,
   fieldBridgeMissingContentMessageSchema,
   fieldBridgeErrorMessageSchema
 ]);
@@ -1428,8 +1485,8 @@ import { z as z17 } from "zod";
 // ../shared/dist/errors.js
 import { z as z16 } from "zod";
 var UI_ERROR_CATEGORIES = [
-  "client",
-  "developer",
+  "site_member",
+  "workspace_member",
   "internal"
 ];
 var uiErrorCategorySchema = z16.enum(UI_ERROR_CATEGORIES);
@@ -1454,52 +1511,79 @@ var commandResultSchema = z17.discriminatedUnion("ok", [
   commandErrorSchema
 ]);
 
-// ../shared/dist/fallback-portal.js
+// ../shared/dist/editor-settings.js
 import { z as z18 } from "zod";
-var FALLBACK_PORTAL_SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-var fallbackPortalSlugSchema = z18.string().regex(FALLBACK_PORTAL_SLUG_PATTERN, "Invalid fallback portal slug");
+var editorColorSchemeSchema = z18.enum([
+  "paper",
+  "slate",
+  "siteplane",
+  "bloom"
+]);
+var editorColorSchemes = editorColorSchemeSchema.options;
+var editorColorModeSchema = z18.enum(["light", "dark"]);
+var editorColorModes = editorColorModeSchema.options;
 
-// ../shared/dist/entitlements.js
+// ../shared/dist/site-slug.js
 import { z as z19 } from "zod";
-var entitlementSnapshotSchema = z19.object({
-  planKey: z19.string().trim().min(1),
-  sitesLimit: z19.number().int().positive(),
-  clientAccountsPerSiteLimit: z19.number().int().positive(),
-  customAdminDomainsEnabled: z19.boolean(),
-  agentMcpEnabled: z19.boolean(),
-  emailNotificationsEnabled: z19.boolean(),
-  analyticsEnabled: z19.boolean(),
-  analyticsSitesLimit: z19.number().int().min(0),
-  analyticsClientPerformanceEnabled: z19.boolean(),
-  analyticsMonthlyReportsEnabled: z19.boolean(),
-  analyticsAiSummaryEnabled: z19.boolean(),
-  analyticsRawEventRetentionDays: z19.number().int().min(1).max(ANALYTICS_RETENTION_DEFAULTS.maxRawEventRetentionDaysWithoutAdr),
-  analyticsMonthlyEventLimit: z19.number().int().min(0),
-  bookingEnabled: z19.boolean().default(false),
-  bookingSitesLimit: z19.number().int().min(0).default(0),
-  bookingClientManagementEnabled: z19.boolean().default(false),
-  bookingResourcesPerSiteLimit: z19.number().int().min(0).default(0),
-  bookingServicesPerSiteLimit: z19.number().int().min(0).default(0),
-  bookingMonthlyBookingsLimit: z19.number().int().min(0).default(0),
-  bookingRemindersEnabled: z19.boolean().default(false)
+var SITE_SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var RESERVED_SITE_SLUGS = /* @__PURE__ */ new Set([
+  "account",
+  "admin",
+  "api",
+  "app",
+  "auth",
+  "book",
+  "claim",
+  "dev",
+  "login",
+  "new",
+  "portal",
+  "support",
+  "workspace"
+]);
+var siteSlugSchema = z19.string().regex(SITE_SLUG_PATTERN, "Invalid site slug").refine((value) => !RESERVED_SITE_SLUGS.has(value), "Reserved site slug");
+
+// ../shared/dist/entitlements.js
+import { z as z20 } from "zod";
+var entitlementSnapshotSchema = z20.object({
+  planKey: z20.string().trim().min(1),
+  sitesLimit: z20.number().int().positive(),
+  siteMembersPerSiteLimit: z20.number().int().positive(),
+  customAdminDomainsEnabled: z20.boolean(),
+  agentMcpEnabled: z20.boolean(),
+  emailNotificationsEnabled: z20.boolean(),
+  analyticsEnabled: z20.boolean(),
+  analyticsSitesLimit: z20.number().int().min(0),
+  analyticsPortalPerformanceEnabled: z20.boolean(),
+  analyticsMonthlyReportsEnabled: z20.boolean(),
+  analyticsAiSummaryEnabled: z20.boolean(),
+  analyticsRawEventRetentionDays: z20.number().int().min(1).max(ANALYTICS_RETENTION_DEFAULTS.maxRawEventRetentionDaysWithoutAdr),
+  analyticsMonthlyEventLimit: z20.number().int().min(0),
+  bookingEnabled: z20.boolean().default(false),
+  bookingSitesLimit: z20.number().int().min(0).default(0),
+  bookingPortalManagementEnabled: z20.boolean().default(false),
+  bookingResourcesPerSiteLimit: z20.number().int().min(0).default(0),
+  bookingServicesPerSiteLimit: z20.number().int().min(0).default(0),
+  bookingMonthlyBookingsLimit: z20.number().int().min(0).default(0),
+  bookingRemindersEnabled: z20.boolean().default(false)
 });
 var EARLY_ACCESS_PLAN = {
   planKey: "early_access_2026",
   sitesLimit: 3,
-  clientAccountsPerSiteLimit: 5,
+  siteMembersPerSiteLimit: 5,
   customAdminDomainsEnabled: true,
   agentMcpEnabled: true,
   emailNotificationsEnabled: true,
   analyticsEnabled: false,
   analyticsSitesLimit: 0,
-  analyticsClientPerformanceEnabled: false,
+  analyticsPortalPerformanceEnabled: false,
   analyticsMonthlyReportsEnabled: false,
   analyticsAiSummaryEnabled: false,
   analyticsRawEventRetentionDays: ANALYTICS_RETENTION_DEFAULTS.enabledRawEventRetentionDays,
   analyticsMonthlyEventLimit: 0,
   bookingEnabled: true,
   bookingSitesLimit: 3,
-  bookingClientManagementEnabled: true,
+  bookingPortalManagementEnabled: true,
   bookingResourcesPerSiteLimit: 10,
   bookingServicesPerSiteLimit: 50,
   bookingMonthlyBookingsLimit: 0,
@@ -1507,7 +1591,7 @@ var EARLY_ACCESS_PLAN = {
 };
 
 // ../shared/dist/readiness.js
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var READINESS_CHECK_KEYS = [
   "agent_instructions_installed",
   "runtime_package_connected",
@@ -1522,19 +1606,19 @@ var READINESS_STATUSES = [
   "failing",
   "warning"
 ];
-var readinessCheckKeySchema = z20.enum(READINESS_CHECK_KEYS);
-var readinessStatusSchema = z20.enum(READINESS_STATUSES);
+var readinessCheckKeySchema = z21.enum(READINESS_CHECK_KEYS);
+var readinessStatusSchema = z21.enum(READINESS_STATUSES);
 
 // ../shared/dist/site.js
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var SITE_STATUSES = [
   "setup",
-  "client_ready",
+  "active",
   "disabled",
   "archived"
 ];
-var siteStatusSchema = z21.enum(SITE_STATUSES);
-var websiteUrlSchema = z21.string().trim().url().refine((value) => value.startsWith("https://") || value.startsWith("http://"), "Website URL must use http or https");
+var siteStatusSchema = z22.enum(SITE_STATUSES);
+var websiteUrlSchema = z22.string().trim().url().refine((value) => value.startsWith("https://") || value.startsWith("http://"), "Website URL must use http or https");
 
 // ../cli/dist/analytics/static-scan.js
 import ts from "typescript";
@@ -1725,16 +1809,16 @@ ${analyticsRulesTemplate}`;
 import { createHash } from "crypto";
 
 // ../cli/dist/commands/analytics/public-key.js
-import { z as z22 } from "zod";
-var responseSchema = z22.object({
-  ok: z22.literal(true),
-  data: z22.object({
-    rawPublicKey: z22.string().regex(/^pk_siteplane_[A-Za-z0-9_-]{16}_[A-Za-z0-9_-]{43}$/)
+import { z as z23 } from "zod";
+var responseSchema = z23.object({
+  ok: z23.literal(true),
+  data: z23.object({
+    rawPublicKey: z23.string().regex(/^pk_siteplane_[A-Za-z0-9_-]{16}_[A-Za-z0-9_-]{43}$/)
   })
 });
-var errorResponseSchema = z22.object({
-  error: z22.object({
-    code: z22.string().regex(/^[a-z][a-z0-9_.-]+$/u)
+var errorResponseSchema = z23.object({
+  error: z23.object({
+    code: z23.string().regex(/^[a-z][a-z0-9_.-]+$/u)
   })
 });
 
@@ -1905,75 +1989,48 @@ async function bookingTestCommand(input) {
   });
 }
 
-// ../cli/dist/commands/export.js
-async function exportCommand(input) {
-  requireContentExportScope(input.tokenScopes);
-  const values = await input.readPublishedValues();
-  if (input.format === "prompt") {
-    return {
-      kind: "prompt",
-      output: Object.entries(values).map(([fieldId, value]) => `${fieldId}: ${JSON.stringify(value)}`).join("\n")
-    };
-  }
-  return {
-    kind: "json",
-    values
-  };
-}
-function requireContentExportScope(scopes) {
-  if (!scopes?.includes("content:export")) {
-    throw new Error("A Project Connection with content:export is required.");
-  }
-}
+// ../cli/dist/commands/connect.js
+import { randomBytes } from "crypto";
+import { z as z27 } from "zod";
 
-// ../cli/dist/config/project-config.js
-import { access, chmod, open, readFile as readFile5, rename, rm } from "fs/promises";
+// ../cli/dist/config/credentials.js
+import { execFile } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
-import { join as join3 } from "path";
-import { z as z23 } from "zod";
-var siteplaneProjectConfigSchema = z23.object({
-  version: z23.literal(1),
-  apiBaseUrl: z23.string().url(),
-  siteId: z23.string().uuid(),
-  publicSiteKeyId: z23.string().uuid(),
-  publicSiteKey: z23.string().trim().min(1),
-  fieldContractHash: z23.string().regex(/^sha256:[0-9a-f]{64}$/iu).optional()
+import { chmod, mkdir as mkdir5, open, readFile as readFile5, rename, rm } from "fs/promises";
+import { dirname as dirname5, join as join3, relative } from "path";
+import { promisify } from "util";
+import { z as z24 } from "zod";
+var siteplaneCredentialsSchema = z24.object({
+  accessToken: z24.string().trim().min(1),
+  siteRevalidationSecret: z24.string().trim().min(1)
 }).strict();
-async function readProjectPackageJson(projectDir) {
-  return JSON.parse(await readFile5(join3(projectDir, "package.json"), "utf8"));
-}
-async function detectNextProject(projectDir) {
-  const packageJson = await readProjectPackageJson(projectDir).catch(() => null);
-  if (packageJson?.dependencies?.next || packageJson?.devDependencies?.next) {
-    return true;
+async function assertLocalCredentialsPathSafe(projectDir, options = {}) {
+  const path = join3(projectDir, ".siteplane/credentials.json");
+  const isTrackedFile = options.isTrackedFile ?? ((targetPath) => gitPathMatches(projectDir, targetPath, "ls-files"));
+  const isIgnoredFile = options.isIgnoredFile ?? ((targetPath) => gitPathMatches(projectDir, targetPath, "check-ignore"));
+  if (await isTrackedFile(path)) {
+    throw new Error("Refusing to write Siteplane credentials into a tracked file.");
   }
-  for (const fileName of [
-    "next.config.js",
-    "next.config.mjs",
-    "next.config.ts"
-  ]) {
-    try {
-      await access(join3(projectDir, fileName));
-      return true;
-    } catch {
-    }
+  if (!await isIgnoredFile(path)) {
+    throw new Error("Add .siteplane/credentials.json to .gitignore before running Siteplane connect.");
   }
-  return false;
+  return path;
 }
-async function writeProjectConfig(projectDir, config) {
-  const path = join3(projectDir, "siteplane.config.json");
-  const parsed = siteplaneProjectConfigSchema.parse(config);
-  await writeJsonAtomically(path, parsed, 420);
+async function writeLocalCredentials(projectDir, credentials, options = {}) {
+  const path = await assertLocalCredentialsPathSafe(projectDir, options);
+  const parsed = siteplaneCredentialsSchema.parse(credentials);
+  await mkdir5(dirname5(path), { recursive: true, mode: 448 });
+  await writeCredentialsAtomically(path, parsed);
   return path;
 }
-async function readProjectConfig(projectDir) {
-  return siteplaneProjectConfigSchema.parse(JSON.parse(await readFile5(join3(projectDir, "siteplane.config.json"), "utf8")));
+async function readLocalCredentials(projectDir) {
+  return siteplaneCredentialsSchema.parse(JSON.parse(await readFile5(join3(projectDir, ".siteplane/credentials.json"), "utf8")));
 }
-async function writeJsonAtomically(path, value, mode) {
+async function writeCredentialsAtomically(path, credentials) {
   const temporaryPath = `${path}.${randomUUID2()}.tmp`;
-  const file = await open(temporaryPath, "wx", mode);
+  const file = await open(temporaryPath, "wx", 384);
   try {
-    await file.writeFile(`${JSON.stringify(value, null, 2)}
+    await file.writeFile(`${JSON.stringify(credentials, null, 2)}
 `, "utf8");
     await file.sync();
   } catch (error) {
@@ -1984,47 +2041,71 @@ async function writeJsonAtomically(path, value, mode) {
   await file.close();
   try {
     await rename(temporaryPath, path);
-    await chmod(path, mode);
+    await chmod(path, 384);
   } catch (error) {
     await rm(temporaryPath, { force: true });
     throw error;
   }
 }
+var execFileAsync = promisify(execFile);
+async function gitPathMatches(projectDir, path, command) {
+  const args = command === "check-ignore" ? ["check-ignore", "--quiet", relative(projectDir, path)] : ["ls-files", "--error-unmatch", relative(projectDir, path)];
+  try {
+    await execFileAsync("git", args, { cwd: projectDir });
+    return true;
+  } catch {
+    return false;
+  }
+}
 
-// ../cli/dist/config/credentials.js
-import { execFile } from "child_process";
+// ../cli/dist/config/project-config.js
+import { access, chmod as chmod2, open as open2, readFile as readFile6, rename as rename2, rm as rm2 } from "fs/promises";
 import { randomUUID as randomUUID3 } from "crypto";
-import { chmod as chmod2, 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 z24 } from "zod";
-var siteplaneCredentialsSchema = z24.object({
-  accessToken: z24.string().trim().min(1),
-  siteRevalidationSecret: z24.string().trim().min(1)
+import { join as join4 } from "path";
+import { z as z25 } from "zod";
+var siteplaneProjectConfigSchema = z25.object({
+  version: z25.literal(1),
+  apiBaseUrl: z25.string().url(),
+  siteId: z25.string().uuid(),
+  publicSiteKeyId: z25.string().uuid(),
+  publicSiteKey: z25.string().trim().min(1),
+  fieldContractHash: z25.string().regex(/^sha256:[0-9a-f]{64}$/iu).optional()
 }).strict();
-async function writeLocalCredentials(projectDir, credentials, options = {}) {
-  const path = join4(projectDir, ".siteplane/credentials.json");
-  const isTrackedFile = options.isTrackedFile ?? ((targetPath) => gitPathMatches(projectDir, targetPath, "ls-files"));
-  const isIgnoredFile = options.isIgnoredFile ?? ((targetPath) => gitPathMatches(projectDir, targetPath, "check-ignore"));
-  if (await isTrackedFile(path)) {
-    throw new Error("Refusing to write Siteplane credentials into a tracked file.");
+async function readProjectPackageJson(projectDir) {
+  return JSON.parse(await readFile6(join4(projectDir, "package.json"), "utf8"));
+}
+async function detectNextProject(projectDir) {
+  const packageJson = await readProjectPackageJson(projectDir).catch(() => null);
+  if (packageJson?.dependencies?.next || packageJson?.devDependencies?.next) {
+    return true;
   }
-  if (!await isIgnoredFile(path)) {
-    throw new Error("Add .siteplane/credentials.json to .gitignore before running siteplane init.");
+  for (const fileName of [
+    "next.config.js",
+    "next.config.mjs",
+    "next.config.ts"
+  ]) {
+    try {
+      await access(join4(projectDir, fileName));
+      return true;
+    } catch {
+    }
   }
-  const parsed = siteplaneCredentialsSchema.parse(credentials);
-  await mkdir5(dirname5(path), { recursive: true, mode: 448 });
-  await writeCredentialsAtomically(path, parsed);
+  return false;
+}
+async function writeProjectConfig(projectDir, config) {
+  const path = join4(projectDir, "siteplane.config.json");
+  const parsed = siteplaneProjectConfigSchema.parse(config);
+  await writeJsonAtomically(path, parsed, 420);
   return path;
 }
-async function readLocalCredentials(projectDir) {
-  return siteplaneCredentialsSchema.parse(JSON.parse(await readFile6(join4(projectDir, ".siteplane/credentials.json"), "utf8")));
+async function readProjectConfig(projectDir) {
+  return siteplaneProjectConfigSchema.parse(JSON.parse(await readFile6(join4(projectDir, "siteplane.config.json"), "utf8")));
 }
-async function writeCredentialsAtomically(path, credentials) {
+async function writeJsonAtomically(path, value, mode) {
   const temporaryPath = `${path}.${randomUUID3()}.tmp`;
-  const file = await open2(temporaryPath, "wx", 384);
+  const file = await open2(temporaryPath, "wx", mode);
   try {
-    await file.writeFile(`${JSON.stringify(credentials, null, 2)}
+    await file.writeFile(`${JSON.stringify(value, null, 2)}
 `, "utf8");
     await file.sync();
   } catch (error) {
@@ -2035,26 +2116,16 @@ async function writeCredentialsAtomically(path, credentials) {
   await file.close();
   try {
     await rename2(temporaryPath, path);
-    await chmod2(path, 384);
+    await chmod2(path, mode);
   } catch (error) {
     await rm2(temporaryPath, { force: true });
     throw error;
   }
 }
-var execFileAsync = promisify(execFile);
-async function gitPathMatches(projectDir, path, command) {
-  const args = command === "check-ignore" ? ["check-ignore", "--quiet", relative(projectDir, path)] : ["ls-files", "--error-unmatch", relative(projectDir, path)];
-  try {
-    await execFileAsync("git", args, { cwd: projectDir });
-    return true;
-  } catch {
-    return false;
-  }
-}
 
 // ../cli/dist/commands/init.js
 import { join as join5 } from "path";
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 async function initCommand(input) {
   if (!input.setupToken.trim()) {
     throw new Error("A Siteplane setup token is required.");
@@ -2074,24 +2145,24 @@ async function initCommand(input) {
     ]
   };
 }
-var siteSetupBootstrapDataSchema = z25.object({
-  credentialPurpose: z25.literal("site_setup"),
-  apiBaseUrl: z25.string().url(),
-  siteId: z25.string().uuid(),
-  publicSiteKeyId: z25.string().uuid(),
-  publicSiteKey: z25.string().trim().min(1),
-  accessToken: z25.string().trim().min(1),
-  siteRevalidationSecret: z25.string().regex(/^[A-Za-z0-9_-]{43}$/u)
+var siteSetupBootstrapDataSchema = z26.object({
+  credentialPurpose: z26.literal("site_setup"),
+  apiBaseUrl: z26.string().url(),
+  siteId: z26.string().uuid(),
+  publicSiteKeyId: z26.string().uuid(),
+  publicSiteKey: z26.string().trim().min(1),
+  accessToken: z26.string().trim().min(1),
+  siteRevalidationSecret: z26.string().regex(/^[A-Za-z0-9_-]{43}$/u)
 }).strict();
-var featureBootstrapDataSchema = z25.object({
-  credentialPurpose: z25.enum(["analytics", "booking"]),
-  apiBaseUrl: z25.string().url(),
-  siteId: z25.string().uuid(),
-  accessToken: z25.string().trim().min(1)
+var featureBootstrapDataSchema = z26.object({
+  credentialPurpose: z26.enum(["analytics", "booking"]),
+  apiBaseUrl: z26.string().url(),
+  siteId: z26.string().uuid(),
+  accessToken: z26.string().trim().min(1)
 }).strict();
-var bootstrapResponseSchema = z25.object({
-  ok: z25.literal(true),
-  data: z25.discriminatedUnion("credentialPurpose", [
+var bootstrapResponseSchema = z26.object({
+  ok: z26.literal(true),
+  data: z26.discriminatedUnion("credentialPurpose", [
     siteSetupBootstrapDataSchema,
     featureBootstrapDataSchema
   ])
@@ -2189,6 +2260,44 @@ function readErrorMessage(payload) {
   return null;
 }
 
+// ../cli/dist/commands/connect.js
+var claimResponseSchema = z27.object({
+  ok: z27.literal(true),
+  data: z27.object({
+    pairingId: z27.string().uuid(),
+    status: z27.literal("approval_required")
+  }).passthrough()
+}).strict();
+var waitingResponseSchema = z27.object({
+  ok: z27.literal(true),
+  data: z27.object({ status: z27.literal("approval_required") }).strict()
+}).strict();
+var bootstrapResponseSchema2 = z27.object({
+  ok: z27.literal(true),
+  data: siteSetupBootstrapDataSchema
+}).strict();
+
+// ../cli/dist/commands/export.js
+async function exportCommand(input) {
+  requireContentExportScope(input.tokenScopes);
+  const values = await input.readPublishedValues();
+  if (input.format === "prompt") {
+    return {
+      kind: "prompt",
+      output: Object.entries(values).map(([fieldId, value]) => `${fieldId}: ${JSON.stringify(value)}`).join("\n")
+    };
+  }
+  return {
+    kind: "json",
+    values
+  };
+}
+function requireContentExportScope(scopes) {
+  if (!scopes?.includes("content:export")) {
+    throw new Error("A Project Connection with content:export is required.");
+  }
+}
+
 // ../cli/dist/commands/scan.js
 import { readdir } from "fs/promises";
 import { extname, join as join6 } from "path";
@@ -2197,7 +2306,7 @@ import { extname, join as join6 } from "path";
 import { execFile as execFile2 } from "child_process";
 import { readFile as readFile7 } from "fs/promises";
 import { promisify as promisify2 } from "util";
-import { z as z26 } from "zod";
+import { z as z28 } from "zod";
 
 // ../cli/dist/scan/next-source-scan.js
 import ts2 from "typescript";
@@ -2207,49 +2316,52 @@ var editableComponentNames = new Set(["Image", "Text", "LongText", "Link"].map((
 
 // ../cli/dist/commands/site-setup.js
 var execFileAsync2 = promisify2(execFile2);
-var safeErrorSchema = z26.object({
-  code: z26.string().trim().min(1),
-  message: z26.string().trim().min(1)
+var safeErrorSchema = z28.object({
+  code: z28.string().trim().min(1),
+  message: z28.string().trim().min(1)
 }).passthrough();
-var errorResponseSchema2 = z26.object({ ok: z26.literal(false), error: safeErrorSchema }).passthrough();
-var contextDataSchema = z26.object({
-  site: z26.object({ siteId: z26.string().uuid(), websiteUrl: z26.string().url() }),
-  run: z26.object({
-    runId: z26.string().uuid(),
-    mode: z26.enum(["initial", "update"]),
-    status: z26.enum([
+var errorResponseSchema2 = z28.object({ ok: z28.literal(false), error: safeErrorSchema }).passthrough();
+var contextDataSchema = z28.object({
+  site: z28.object({ siteId: z28.string().uuid(), portalPath: z28.string() }),
+  run: z28.object({
+    runId: z28.string().uuid(),
+    mode: z28.enum(["initial", "update"]),
+    status: z28.enum([
       "waiting_for_agent",
       "working",
       "action_required",
       "ready_for_review"
     ]),
-    fieldContractHash: z26.string().nullable(),
-    deploymentOrigin: z26.string().nullable(),
-    deploymentRevision: z26.string().nullable(),
-    errorCode: z26.string().nullable(),
-    errorMessage: z26.string().nullable()
+    fieldContractHash: z28.string().nullable(),
+    deploymentOrigin: z28.string().nullable(),
+    deploymentRevision: z28.string().nullable(),
+    errorCode: z28.string().nullable(),
+    errorMessage: z28.string().nullable()
   }),
-  allowedTasks: z26.array(z26.string()),
-  requiredEnvironmentNames: z26.array(z26.string())
+  structureHandoff: z28.object({
+    pendingFields: z28.array(setupCorrectionItemSchema).min(1).max(50)
+  }).strict().nullable(),
+  allowedTasks: z28.array(z28.string()),
+  requiredEnvironmentNames: z28.array(z28.string())
 }).strict();
-var contextResponseSchema = z26.object({ ok: z26.literal(true), data: contextDataSchema }).strict();
-var applyDataSchema = z26.object({
-  status: z26.enum(["applied", "ready_for_review"]),
-  runId: z26.string().uuid().optional(),
-  contractVersionId: z26.string().uuid().optional(),
-  fieldContractHash: z26.string().regex(/^sha256:[0-9a-f]{64}$/u),
-  editorDefinitionHash: z26.string().regex(/^sha256:[0-9a-f]{64}$/u).optional(),
-  fieldCount: z26.number().int().nonnegative().optional(),
-  routeCount: z26.number().int().nonnegative().optional()
+var contextResponseSchema = z28.object({ ok: z28.literal(true), data: contextDataSchema }).strict();
+var applyDataSchema = z28.object({
+  status: z28.enum(["applied", "ready_for_review"]),
+  runId: z28.string().uuid().optional(),
+  contractVersionId: z28.string().uuid().optional(),
+  fieldContractHash: z28.string().regex(/^sha256:[0-9a-f]{64}$/u),
+  editorDefinitionHash: z28.string().regex(/^sha256:[0-9a-f]{64}$/u).optional(),
+  fieldCount: z28.number().int().nonnegative().optional(),
+  routeCount: z28.number().int().nonnegative().optional()
 }).strict();
-var applyResponseSchema = z26.object({ ok: z26.literal(true), data: applyDataSchema }).strict();
-var verifyDataSchema = z26.object({
-  status: z26.literal("ready_for_review"),
-  runId: z26.string().uuid().optional(),
-  deploymentOrigin: z26.string().url().optional(),
-  deploymentRevision: z26.string().optional()
+var applyResponseSchema = z28.object({ ok: z28.literal(true), data: applyDataSchema }).strict();
+var verifyDataSchema = z28.object({
+  status: z28.literal("ready_for_review"),
+  runId: z28.string().uuid().optional(),
+  deploymentOrigin: z28.string().url().optional(),
+  deploymentRevision: z28.string().optional()
 }).strict();
-var verifyResponseSchema = z26.object({ ok: z26.literal(true), data: verifyDataSchema }).strict();
+var verifyResponseSchema = z28.object({ ok: z28.literal(true), data: verifyDataSchema }).strict();
 export {
   bookingCheckCommand,
   bookingInitCommand,