clientplane 0.0.0-reserved.0

package/dist/index.js

@@ -0,0 +1,885 @@
+// ../cli/dist/commands/backfill.js
+async function backfillCommand(input) {
+  const values = await input.readPublishedValues();
+  const lines = input.manifest.fields.filter((field) => Object.hasOwn(values, field.fieldId)).map((field) => `Update ${field.fieldId} fallback in ${field.sourceFilePath ?? "the source file"} to ${JSON.stringify(values[field.fieldId])}.`);
+  return {
+    appliesAutomatically: false,
+    instructions: lines.join("\n")
+  };
+}
+
+// ../cli/dist/commands/scan.js
+import { readFile } from "fs/promises";
+
+// ../cli/dist/scan/next-source-scan.js
+import ts from "typescript";
+
+// ../shared/dist/actors.js
+import { z } from "zod";
+var ACTOR_TYPES = ["developer", "client", "agent", "system"];
+var actorTypeSchema = z.enum(ACTOR_TYPES);
+
+// ../shared/dist/assets.js
+import { z as z2 } from "zod";
+var ASSET_STAGES = ["staging", "final", "deleted"];
+var ASSET_VISIBILITIES = ["private", "public", "deleted"];
+var ASSET_USAGE_ENTITY_TYPES = [
+  "branding",
+  "draft",
+  "change_set",
+  "published_value"
+];
+var assetStageSchema = z2.enum(ASSET_STAGES);
+var assetVisibilitySchema = z2.enum(ASSET_VISIBILITIES);
+var assetUsageEntityTypeSchema = z2.enum(ASSET_USAGE_ENTITY_TYPES);
+var brandingAccentColorSchema = z2.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/);
+
+// ../shared/dist/bridge-protocol.js
+import { z as z5 } from "zod";
+
+// ../shared/dist/field-id.js
+import { z as z3 } from "zod";
+var FIELD_ID_PATTERN = /^[a-z][a-z0-9_-]*(\.[a-z][a-z0-9_-]*)+$/;
+var fieldIdSchema = z3.string().regex(FIELD_ID_PATTERN, "Invalid field id");
+function isFieldId(value) {
+  return typeof value === "string" && fieldIdSchema.safeParse(value).success;
+}
+
+// ../shared/dist/field-types.js
+import { z as z4 } from "zod";
+var FIELD_TYPES = ["text", "longText", "image", "link"];
+var fieldTypeSchema = z4.enum(FIELD_TYPES);
+
+// ../shared/dist/bridge-protocol.js
+var BRIDGE_PROTOCOL_VERSION = 1;
+var BRIDGE_MESSAGE_TYPES = [
+  "clientplane:bridge:init",
+  "clientplane:bridge:ready",
+  "clientplane:bridge:fields",
+  "clientplane:bridge:select-field",
+  "clientplane:bridge:apply-preview-values",
+  "clientplane:bridge:test-preview-value",
+  "clientplane:bridge:ack",
+  "clientplane:bridge:error"
+];
+var bridgeMessageTypeSchema = z5.enum(BRIDGE_MESSAGE_TYPES);
+var bridgeBaseSchema = z5.object({
+  version: z5.literal(BRIDGE_PROTOCOL_VERSION),
+  type: bridgeMessageTypeSchema,
+  siteId: z5.string().uuid(),
+  sessionId: z5.string().trim().min(1),
+  requestId: z5.string().trim().min(1),
+  sentAt: z5.string().datetime()
+});
+var bridgeRectSchema = z5.object({
+  x: z5.number(),
+  y: z5.number(),
+  width: z5.number().nonnegative(),
+  height: z5.number().nonnegative()
+});
+var bridgeFieldSchema = z5.object({
+  fieldId: fieldIdSchema,
+  fieldType: fieldTypeSchema,
+  route: z5.string().regex(/^\/.*/),
+  routeId: z5.string().trim().min(1).optional(),
+  sourcePath: z5.string().trim().min(1).optional(),
+  editTarget: fieldIdSchema,
+  manifestVersion: z5.string().trim().min(1).optional(),
+  rect: bridgeRectSchema,
+  editable: z5.boolean(),
+  label: z5.string().trim().min(1).optional()
+});
+var bridgeInitPayloadSchema = z5.object({
+  adminOrigin: z5.string().url(),
+  customerOrigin: z5.string().url(),
+  route: z5.string().regex(/^\/.*/)
+});
+var bridgeReadyPayloadSchema = z5.object({
+  route: z5.string().regex(/^\/.*/),
+  fieldCount: z5.number().int().nonnegative()
+});
+var bridgeFieldsPayloadSchema = z5.object({
+  route: z5.string().regex(/^\/.*/),
+  fields: z5.array(bridgeFieldSchema)
+});
+var bridgeSelectFieldPayloadSchema = z5.object({
+  fieldId: fieldIdSchema,
+  source: z5.enum(["runtime", "editor"]).default("runtime")
+});
+var previewTextValueSchema = z5.object({
+  fieldType: z5.enum(["text", "longText"]),
+  value: z5.string()
+});
+var previewLinkValueSchema = z5.object({
+  fieldType: z5.literal("link"),
+  value: z5.object({
+    href: z5.string().trim().min(1),
+    label: z5.string().trim().min(1).optional()
+  })
+});
+var previewImageValueSchema = z5.object({
+  fieldType: z5.literal("image"),
+  value: z5.object({
+    src: z5.string().trim().min(1),
+    alt: z5.string().trim().min(1)
+  })
+});
+var bridgePreviewValueSchema = z5.discriminatedUnion("fieldType", [
+  previewTextValueSchema,
+  previewLinkValueSchema,
+  previewImageValueSchema
+]);
+var bridgeApplyPreviewValuesPayloadSchema = z5.object({
+  values: z5.record(fieldIdSchema, bridgePreviewValueSchema)
+});
+var bridgeTestPreviewValuePayloadSchema = z5.object({
+  fieldIds: z5.array(fieldIdSchema).min(1)
+});
+var bridgeAckPayloadSchema = z5.object({
+  ackRequestId: z5.string().trim().min(1)
+});
+var bridgeErrorPayloadSchema = z5.object({
+  code: z5.string().trim().min(1),
+  message: z5.string().trim().min(1),
+  recoverable: z5.boolean().default(false)
+});
+var bridgeInitMessageSchema = bridgeBaseSchema.extend({
+  type: z5.literal("clientplane:bridge:init"),
+  payload: bridgeInitPayloadSchema
+});
+var bridgeReadyMessageSchema = bridgeBaseSchema.extend({
+  type: z5.literal("clientplane:bridge:ready"),
+  payload: bridgeReadyPayloadSchema
+});
+var bridgeFieldsMessageSchema = bridgeBaseSchema.extend({
+  type: z5.literal("clientplane:bridge:fields"),
+  payload: bridgeFieldsPayloadSchema
+});
+var bridgeSelectFieldMessageSchema = bridgeBaseSchema.extend({
+  type: z5.literal("clientplane:bridge:select-field"),
+  payload: bridgeSelectFieldPayloadSchema
+});
+var bridgeApplyPreviewValuesMessageSchema = bridgeBaseSchema.extend({
+  type: z5.literal("clientplane:bridge:apply-preview-values"),
+  payload: bridgeApplyPreviewValuesPayloadSchema
+});
+var bridgeTestPreviewValueMessageSchema = bridgeBaseSchema.extend({
+  type: z5.literal("clientplane:bridge:test-preview-value"),
+  payload: bridgeTestPreviewValuePayloadSchema
+});
+var bridgeAckMessageSchema = bridgeBaseSchema.extend({
+  type: z5.literal("clientplane:bridge:ack"),
+  payload: bridgeAckPayloadSchema
+});
+var bridgeErrorMessageSchema = bridgeBaseSchema.extend({
+  type: z5.literal("clientplane:bridge:error"),
+  payload: bridgeErrorPayloadSchema
+});
+var bridgeMessageSchema = z5.discriminatedUnion("type", [
+  bridgeInitMessageSchema,
+  bridgeReadyMessageSchema,
+  bridgeFieldsMessageSchema,
+  bridgeSelectFieldMessageSchema,
+  bridgeApplyPreviewValuesMessageSchema,
+  bridgeTestPreviewValueMessageSchema,
+  bridgeAckMessageSchema,
+  bridgeErrorMessageSchema
+]);
+
+// ../shared/dist/commands.js
+import { z as z7 } from "zod";
+
+// ../shared/dist/errors.js
+import { z as z6 } from "zod";
+var UI_ERROR_CATEGORIES = [
+  "client",
+  "developer",
+  "internal"
+];
+var uiErrorCategorySchema = z6.enum(UI_ERROR_CATEGORIES);
+var commandErrorPayloadSchema = z6.object({
+  code: z6.string().min(1),
+  message: z6.string().min(1),
+  category: uiErrorCategorySchema,
+  details: z6.record(z6.string(), z6.unknown()).optional()
+});
+
+// ../shared/dist/commands.js
+var commandSuccessSchema = z7.object({
+  ok: z7.literal(true),
+  data: z7.unknown()
+});
+var commandErrorSchema = z7.object({
+  ok: z7.literal(false),
+  error: commandErrorPayloadSchema
+});
+var commandResultSchema = z7.discriminatedUnion("ok", [
+  commandSuccessSchema,
+  commandErrorSchema
+]);
+
+// ../shared/dist/field-manifest.js
+import { z as z8 } from "zod";
+var FIELD_MANIFEST_CHANGE_TYPES = [
+  "new",
+  "changed",
+  "removed",
+  "rename_candidate"
+];
+var FIELD_MANIFEST_REVIEW_STATUSES = [
+  "pending",
+  "approved",
+  "rejected",
+  "needs_fix",
+  "resolved"
+];
+var FIELD_DEFINITION_STATUSES = [
+  "active",
+  "hidden",
+  "orphaned",
+  "archived"
+];
+var fieldManifestChangeTypeSchema = z8.enum(FIELD_MANIFEST_CHANGE_TYPES);
+var fieldManifestReviewStatusSchema = z8.enum(FIELD_MANIFEST_REVIEW_STATUSES);
+var fieldDefinitionStatusSchema = z8.enum(FIELD_DEFINITION_STATUSES);
+var manifestRouteSchema = z8.object({
+  path: z8.string().regex(/^\/.*/),
+  label: z8.string().trim().min(1).optional()
+});
+var fieldManifestFieldSchema = z8.object({
+  fieldId: fieldIdSchema,
+  fieldType: fieldTypeSchema,
+  fallback: z8.unknown().optional(),
+  label: z8.string().trim().min(1).optional(),
+  description: z8.string().trim().min(1).optional(),
+  required: z8.boolean().optional(),
+  maxLength: z8.number().int().positive().optional(),
+  routeHint: z8.string().regex(/^\/.*/).optional(),
+  routeId: z8.string().trim().min(1).optional(),
+  sourcePath: z8.string().trim().min(1).optional(),
+  editTarget: fieldIdSchema.optional(),
+  lastSeenRoute: z8.string().regex(/^\/.*/).optional(),
+  positionHint: z8.record(z8.string(), z8.unknown()).optional(),
+  domSelectorHint: z8.string().trim().min(1).optional(),
+  source: z8.enum(["component", "function", "runtime"]).default("component"),
+  sourceFilePath: z8.string().trim().min(1).optional(),
+  sourceExportName: z8.string().trim().min(1).optional(),
+  componentHint: z8.string().trim().min(1).optional(),
+  validation: z8.record(z8.string(), z8.unknown()).optional(),
+  metadata: z8.record(z8.string(), z8.unknown()).optional(),
+  warnings: z8.array(z8.string().trim().min(1)).default([]),
+  suggestions: z8.array(z8.string().trim().min(1)).default([])
+});
+var fieldManifestSchema = z8.object({
+  version: z8.literal(1),
+  siteId: z8.string().uuid().optional(),
+  fields: z8.array(fieldManifestFieldSchema),
+  routes: z8.array(manifestRouteSchema).default([])
+}).superRefine((manifest, context) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const field of manifest.fields) {
+    if (seen.has(field.fieldId)) {
+      context.addIssue({
+        code: "custom",
+        path: ["fields"],
+        message: `Duplicate field id: ${field.fieldId}`
+      });
+    }
+    seen.add(field.fieldId);
+  }
+});
+
+// ../shared/dist/fallback-portal.js
+import { z as z9 } from "zod";
+var FALLBACK_PORTAL_SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var fallbackPortalSlugSchema = z9.string().regex(FALLBACK_PORTAL_SLUG_PATTERN, "Invalid fallback portal slug");
+
+// ../shared/dist/entitlements.js
+import { z as z10 } from "zod";
+var entitlementSnapshotSchema = z10.object({
+  planKey: z10.string().trim().min(1),
+  sitesLimit: z10.number().int().positive(),
+  clientAccountsPerSiteLimit: z10.number().int().positive(),
+  customAdminDomainsEnabled: z10.boolean(),
+  agentMcpEnabled: z10.boolean(),
+  emailNotificationsEnabled: z10.boolean()
+});
+
+// ../shared/dist/image-value.js
+import { z as z11 } from "zod";
+var SUPPORTED_IMAGE_CONTENT_TYPES = [
+  "image/jpeg",
+  "image/png",
+  "image/webp",
+  "image/avif"
+];
+var maxImageUploadBytes = 10 * 1024 * 1024;
+var largeImageWarningBytes = 2 * 1024 * 1024;
+var imageContentTypeSchema = z11.enum(SUPPORTED_IMAGE_CONTENT_TYPES);
+var imageCropSchema = z11.object({
+  x: z11.number().min(0).max(100),
+  y: z11.number().min(0).max(100),
+  zoom: z11.number().min(1).max(4),
+  aspectRatio: z11.number().positive().max(10)
+});
+var imageValueSchema = z11.object({
+  src: z11.string().trim().min(1),
+  alt: z11.string().trim().min(1).max(300),
+  width: z11.number().int().positive().optional(),
+  height: z11.number().int().positive().optional(),
+  crop: imageCropSchema.optional(),
+  assetId: z11.string().uuid().optional(),
+  finalStorageProvider: z11.enum([
+    "repo_static_assets",
+    "repo_handoff",
+    "site_owned_storage",
+    "clientplane_managed_fallback"
+  ]).optional()
+});
+
+// ../shared/dist/readiness.js
+import { z as z12 } from "zod";
+var READINESS_CHECK_KEYS = [
+  "agent_instructions_installed",
+  "manual_setup_confirmed",
+  "runtime_package_connected",
+  "secure_server_access_configured",
+  "manifest_synced",
+  "approved_field_exists",
+  "pending_manifest_changes_clear",
+  "preview_bridge_working",
+  "admin_access_url_selected",
+  "default_publishing_mode_selected"
+];
+var READINESS_STATUSES = [
+  "pending",
+  "passing",
+  "failing",
+  "warning"
+];
+var readinessCheckKeySchema = z12.enum(READINESS_CHECK_KEYS);
+var readinessStatusSchema = z12.enum(READINESS_STATUSES);
+
+// ../shared/dist/site.js
+import { z as z13 } from "zod";
+var SITE_STATUSES = [
+  "setup",
+  "client_ready",
+  "disabled",
+  "archived"
+];
+var siteStatusSchema = z13.enum(SITE_STATUSES);
+var websiteUrlSchema = z13.string().trim().url().refine((value) => value.startsWith("https://") || value.startsWith("http://"), "Website URL must use http or https");
+
+// ../cli/dist/scan/next-source-scan.js
+var editableComponentNames = /* @__PURE__ */ new Set([
+  "EditableImage",
+  "EditableText",
+  "EditableLongText",
+  "EditableLink"
+]);
+var functionTypeByName = {
+  text: "text",
+  longText: "longText",
+  link: "link",
+  image: "image"
+};
+function scanNextSourceFiles(files) {
+  const fields = [];
+  const hardErrors = [];
+  const warnings = [];
+  const suggestions = [];
+  for (const file of files) {
+    scanSourceFile(file, fields, hardErrors);
+  }
+  validateScannedFields(fields, hardErrors, warnings, suggestions);
+  const manifest = fieldManifestSchema.parse({
+    version: 1,
+    fields: uniqueFields(fields).filter((field) => isFieldId(field.fieldId)),
+    routes: createRoutes(fields)
+  });
+  return {
+    manifest,
+    hardErrors,
+    warnings,
+    suggestions
+  };
+}
+function uniqueFields(fields) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const field of fields) {
+    if (seen.has(field.fieldId)) {
+      continue;
+    }
+    seen.add(field.fieldId);
+    unique.push(field);
+  }
+  return unique;
+}
+function scanSourceFile(file, fields, hardErrors) {
+  const fieldsInFile = [];
+  const attrFieldIds = /* @__PURE__ */ new Set();
+  const attrRouteRefs = /* @__PURE__ */ new Set();
+  const sourceFile = ts.createSourceFile(file.filePath, file.sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+  function visit(node) {
+    if (ts.isJsxSelfClosingElement(node) || ts.isJsxOpeningElement(node)) {
+      const componentName = getJsxTagName(node.tagName);
+      if (editableComponentNames.has(componentName)) {
+        hardErrors.push({
+          code: "field_scan.value_first_required",
+          message: "Clientplane MVP uses value-first APIs. Replace this field with clientplane.route(...) or a field value call.",
+          filePath: file.filePath
+        });
+      }
+    }
+    if (ts.isCallExpression(node)) {
+      collectAttrsCall(node, attrFieldIds, attrRouteRefs);
+      const extractedFields = extractFunctionFields(node, file);
+      for (const field of extractedFields) {
+        fieldsInFile.push(field);
+        fields.push(field);
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  markMissingAttrsWarnings(fieldsInFile, attrFieldIds, attrRouteRefs);
+}
+function extractFunctionFields(node, file) {
+  if (!ts.isPropertyAccessExpression(node.expression)) {
+    return [];
+  }
+  if (node.expression.expression.getText() !== "clientplane") {
+    return [];
+  }
+  const functionName = node.expression.name.text;
+  if (functionName === "route") {
+    return extractRouteFields(node, file);
+  }
+  const fieldType = functionTypeByName[functionName];
+  if (!fieldType) {
+    return [];
+  }
+  const fieldId = staticExpressionValue(node.arguments[0]);
+  if (typeof fieldId !== "string") {
+    return [];
+  }
+  const input = {
+    fieldId,
+    fieldType,
+    fallback: staticExpressionValue(node.arguments[1]),
+    source: "function",
+    sourceFilePath: file.filePath,
+    sourceExportName: functionName,
+    editTarget: fieldId
+  };
+  const routeHint = inferRouteHint(file.filePath);
+  const options = staticExpressionValue(node.arguments[2]);
+  const fieldOptions = options && typeof options === "object" && !Array.isArray(options) ? options : {};
+  assignIfDefined(input, "routeHint", routeHint);
+  assignIfDefined(input, "label", stringValue(fieldOptions.label));
+  assignIfDefined(input, "description", stringValue(fieldOptions.description));
+  assignIfDefined(input, "required", booleanValue(fieldOptions.required));
+  assignIfDefined(input, "maxLength", numberValue(fieldOptions.maxLength));
+  return [createField(input)];
+}
+function extractRouteFields(node, file) {
+  const routeId = staticExpressionValue(node.arguments[0]);
+  const fallbacks = staticExpressionValue(node.arguments[1]);
+  const options = staticExpressionValue(node.arguments[2]);
+  if (typeof routeId !== "string" || !fallbacks || typeof fallbacks !== "object" || Array.isArray(fallbacks)) {
+    return [];
+  }
+  const routeVariableName = getAssignedVariableName(node);
+  const fieldsConfig = options && typeof options === "object" && !Array.isArray(options) ? options.fields : void 0;
+  const routeHint = inferRouteHint(file.filePath);
+  const fields = [];
+  for (const [key, fallback] of Object.entries(fallbacks)) {
+    const config = fieldsConfig && typeof fieldsConfig === "object" && !Array.isArray(fieldsConfig) ? fieldsConfig[key] : void 0;
+    if (!config || typeof config !== "object" || Array.isArray(config)) {
+      continue;
+    }
+    const fieldConfig = config;
+    const fieldId = stringValue(fieldConfig.id);
+    const fieldType = fieldTypeValue(fieldConfig.type);
+    if (!fieldId || !fieldType) {
+      continue;
+    }
+    const input = {
+      fieldId,
+      fieldType,
+      fallback,
+      source: "function",
+      sourceFilePath: file.filePath,
+      sourceExportName: "route",
+      routeId,
+      sourcePath: `$.${key}`,
+      editTarget: fieldId,
+      routeFieldKey: key
+    };
+    assignIfDefined(input, "routeVariableName", routeVariableName);
+    assignIfDefined(input, "routeHint", routeHint);
+    assignIfDefined(input, "label", stringValue(fieldConfig.label));
+    assignIfDefined(input, "description", stringValue(fieldConfig.description));
+    assignIfDefined(input, "required", booleanValue(fieldConfig.required));
+    assignIfDefined(input, "maxLength", numberValue(fieldConfig.maxLength));
+    fields.push(createField(input));
+  }
+  return fields;
+}
+function createField(input) {
+  const field = {
+    fieldId: input.fieldId,
+    fieldType: input.fieldType,
+    fallback: input.fallback,
+    source: input.source,
+    sourceFilePath: input.sourceFilePath,
+    warnings: [],
+    suggestions: []
+  };
+  assignIfDefined(field, "label", input.label);
+  assignIfDefined(field, "description", input.description);
+  assignIfDefined(field, "required", input.required);
+  assignIfDefined(field, "maxLength", input.maxLength);
+  assignIfDefined(field, "sourceExportName", input.sourceExportName);
+  assignIfDefined(field, "componentHint", input.componentHint);
+  assignIfDefined(field, "routeHint", input.routeHint);
+  assignIfDefined(field, "routeId", input.routeId);
+  assignIfDefined(field, "sourcePath", input.sourcePath);
+  assignIfDefined(field, "editTarget", input.editTarget);
+  assignIfDefined(field, "routeVariableName", input.routeVariableName);
+  assignIfDefined(field, "routeFieldKey", input.routeFieldKey);
+  if (field.fieldType === "text" && field.maxLength === void 0) {
+    field.warnings.push("field_scan.text_max_length_missing");
+  }
+  if (isPositionalFieldReference(field.fieldId) || isPositionalFieldReference(field.sourcePath)) {
+    field.warnings.push("field_scan.positional_repeating_id");
+  }
+  return field;
+}
+function collectAttrsCall(node, attrFieldIds, attrRouteRefs) {
+  if (!ts.isPropertyAccessExpression(node.expression)) {
+    return;
+  }
+  if (node.expression.expression.getText() !== "clientplane" || node.expression.name.text !== "attrs") {
+    return;
+  }
+  const firstArg = node.arguments[0];
+  const secondArg = staticExpressionValue(node.arguments[1]);
+  const directFieldId = staticExpressionValue(firstArg);
+  if (typeof directFieldId === "string") {
+    attrFieldIds.add(directFieldId);
+    return;
+  }
+  if (firstArg && ts.isIdentifier(firstArg) && typeof secondArg === "string") {
+    attrRouteRefs.add(`${firstArg.text}:${secondArg}`);
+  }
+}
+function markMissingAttrsWarnings(fields, attrFieldIds, attrRouteRefs) {
+  for (const field of fields) {
+    if (field.fieldType !== "text" && field.fieldType !== "longText") {
+      continue;
+    }
+    const hasDirectAttrs = attrFieldIds.has(field.fieldId);
+    const hasRouteAttrs = field.routeVariableName && field.routeFieldKey ? attrRouteRefs.has(`${field.routeVariableName}:${field.routeFieldKey}`) : false;
+    if (!hasDirectAttrs && !hasRouteAttrs) {
+      field.warnings.push("field_scan.attrs_missing");
+    }
+  }
+}
+function validateScannedFields(fields, hardErrors, warnings, suggestions) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const field of fields) {
+    if (!isFieldId(field.fieldId)) {
+      hardErrors.push({
+        code: "field_scan.invalid_field_id",
+        message: `Invalid field id: ${field.fieldId}`,
+        fieldId: field.fieldId,
+        filePath: field.sourceFilePath ?? "unknown"
+      });
+    }
+    const existing = seen.get(field.fieldId);
+    if (existing) {
+      hardErrors.push({
+        code: "field_scan.duplicate_id",
+        message: `Duplicate field id: ${field.fieldId}`,
+        fieldId: field.fieldId,
+        filePath: field.sourceFilePath ?? "unknown"
+      });
+      if (existing.fieldType !== field.fieldType) {
+        hardErrors.push({
+          code: "field_scan.type_conflict",
+          message: `Field id ${field.fieldId} is used with multiple types.`,
+          fieldId: field.fieldId,
+          filePath: field.sourceFilePath ?? "unknown"
+        });
+      }
+    }
+    seen.set(field.fieldId, field);
+    for (const warning of field.warnings) {
+      warnings.push({
+        code: warning,
+        message: getScanIssueMessage(warning),
+        fieldId: field.fieldId,
+        filePath: field.sourceFilePath ?? "unknown"
+      });
+    }
+    for (const suggestion of field.suggestions) {
+      suggestions.push({
+        code: suggestion,
+        message: getScanIssueMessage(suggestion),
+        fieldId: field.fieldId,
+        filePath: field.sourceFilePath ?? "unknown"
+      });
+    }
+  }
+}
+function getScanIssueMessage(code) {
+  if (code === "field_scan.attrs_missing") {
+    return "Field renders a value but has no DOM discovery attrs. Add clientplane.attrs(...) to the nearest stable element so the visual editor can select it.";
+  }
+  if (code === "field_scan.positional_repeating_id") {
+    return "Repeating content needs stable Clientplane field IDs for the MVP. Replace positional array/index field ids with stable item ids such as services.haircut.price.";
+  }
+  if (code === "field_scan.animation_wrapper") {
+    return 'Put clientplane.attrs(...) on the stable wrapper and make the animation respect data-clientplane-editor="true" or useClientplaneEditorMode().';
+  }
+  return code;
+}
+function staticExpressionValue(expression) {
+  if (!expression) {
+    return void 0;
+  }
+  if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.text;
+  }
+  if (ts.isNumericLiteral(expression)) {
+    return Number(expression.text);
+  }
+  if (expression.kind === ts.SyntaxKind.TrueKeyword) {
+    return true;
+  }
+  if (expression.kind === ts.SyntaxKind.FalseKeyword) {
+    return false;
+  }
+  if (ts.isObjectLiteralExpression(expression)) {
+    return readObjectLiteral(expression);
+  }
+  return void 0;
+}
+function readObjectLiteral(expression) {
+  const value = {};
+  for (const property of expression.properties) {
+    if (!ts.isPropertyAssignment(property)) {
+      continue;
+    }
+    const name = getPropertyName(property.name);
+    if (!name) {
+      continue;
+    }
+    value[name] = staticExpressionValue(property.initializer);
+  }
+  return value;
+}
+function getPropertyName(name) {
+  if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
+    return name.text;
+  }
+  return null;
+}
+function getAssignedVariableName(node) {
+  let current = node;
+  while (ts.isAwaitExpression(current.parent)) {
+    current = current.parent;
+  }
+  if (ts.isVariableDeclaration(current.parent) && ts.isIdentifier(current.parent.name)) {
+    return current.parent.name.text;
+  }
+  return void 0;
+}
+function getJsxTagName(tagName) {
+  return tagName.getText();
+}
+function stringValue(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function fieldTypeValue(value) {
+  if (value === "text" || value === "longText" || value === "image" || value === "link") {
+    return value;
+  }
+  return void 0;
+}
+function numberValue(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function booleanValue(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function assignIfDefined(object, key, value) {
+  if (value !== void 0) {
+    object[key] = value;
+  }
+}
+function inferRouteHint(filePath) {
+  const normalized = filePath.replaceAll("\\", "/");
+  const appIndex = normalized.indexOf("app/");
+  if (appIndex === -1 || !normalized.endsWith("page.tsx")) {
+    return void 0;
+  }
+  const route = normalized.slice(appIndex + 4, -"page.tsx".length).split("/").filter((segment) => segment && !segment.startsWith("(")).join("/");
+  return route ? `/${route}` : "/";
+}
+function isPositionalFieldReference(value) {
+  return value ? /\[\d+\]|\.\d+(?:\.|$)/.test(value) : false;
+}
+function createRoutes(fields) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const field of fields) {
+    if (field.routeHint) {
+      paths.add(field.routeHint);
+    }
+  }
+  return [...paths].map((path) => ({ path }));
+}
+
+// ../cli/dist/commands/scan.js
+async function scanCommand(filePaths) {
+  const files = await Promise.all(filePaths.map(async (filePath) => ({
+    filePath,
+    sourceText: await readFile(filePath, "utf8")
+  })));
+  return scanNextSourceFiles(files);
+}
+
+// ../cli/dist/commands/check.js
+async function checkCommand(filePaths) {
+  const result = await scanCommand(filePaths);
+  return {
+    ok: result.hardErrors.length === 0,
+    hardErrorCount: result.hardErrors.length,
+    warningCount: result.warnings.length,
+    warnings: result.warnings
+  };
+}
+
+// ../cli/dist/commands/export.js
+async function exportCommand(input) {
+  return {
+    kind: "json",
+    values: await input.readPublishedValues()
+  };
+}
+
+// ../cli/dist/config/project-config.js
+import { access, readFile as readFile2, writeFile } from "fs/promises";
+import { join } from "path";
+import { z as z14 } from "zod";
+var clientplaneProjectConfigSchema = z14.object({
+  apiBaseUrl: z14.string().url(),
+  siteId: z14.string().trim().min(1),
+  workspaceId: z14.string().trim().min(1),
+  publicSiteKey: z14.string().trim().min(1),
+  manifestPath: z14.string().trim().min(1).default("clientplane.manifest.json")
+});
+async function readProjectPackageJson(projectDir) {
+  return JSON.parse(await readFile2(join(projectDir, "package.json"), "utf8"));
+}
+async function detectNextProject(projectDir) {
+  const packageJson = await readProjectPackageJson(projectDir).catch(() => null);
+  if (packageJson?.dependencies?.next || packageJson?.devDependencies?.next) {
+    return true;
+  }
+  for (const fileName of ["next.config.js", "next.config.mjs", "next.config.ts"]) {
+    try {
+      await access(join(projectDir, fileName));
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+async function writeProjectConfig(projectDir, config) {
+  const parsed = clientplaneProjectConfigSchema.parse(config);
+  const path = join(projectDir, "clientplane.config.json");
+  await writeFile(path, `${JSON.stringify(parsed, null, 2)}
+`, "utf8");
+  return path;
+}
+
+// ../cli/dist/config/credentials.js
+import { mkdir, writeFile as writeFile2 } from "fs/promises";
+import { dirname, join as join2 } from "path";
+import { z as z15 } from "zod";
+var localCredentialsSchema = z15.object({
+  apiBaseUrl: z15.string().url(),
+  accessToken: z15.string().trim().min(1)
+});
+async function writeLocalCredentials(projectDir, credentials, options = {}) {
+  const path = join2(projectDir, ".clientplane/credentials.json");
+  if (await options.isTrackedFile?.(path)) {
+    throw new Error("Refusing to write Clientplane credentials into a tracked file.");
+  }
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile2(path, `${JSON.stringify(localCredentialsSchema.parse(credentials), null, 2)}
+`, "utf8");
+  return path;
+}
+
+// ../cli/dist/commands/init.js
+async function initCommand(input) {
+  if (!input.setupToken.trim()) {
+    throw new Error("A Clientplane setup token is required.");
+  }
+  if (!await detectNextProject(input.projectDir)) {
+    throw new Error("Clientplane init currently supports Next.js projects.");
+  }
+  const configPath = await writeProjectConfig(input.projectDir, {
+    apiBaseUrl: input.apiBaseUrl,
+    siteId: input.siteId,
+    workspaceId: input.workspaceId,
+    publicSiteKey: input.publicSiteKey,
+    manifestPath: "clientplane.manifest.json"
+  });
+  const credentialsPath = await writeLocalCredentials(input.projectDir, {
+    apiBaseUrl: input.apiBaseUrl,
+    accessToken: input.projectConnectionToken
+  }, input.isTrackedFile ? { isTrackedFile: input.isTrackedFile } : {});
+  return {
+    configPath,
+    credentialsPath,
+    nextSteps: [
+      "npm install @clientplane/runtime-next",
+      "clientplane check",
+      "clientplane scan",
+      "clientplane sync"
+    ]
+  };
+}
+
+// ../cli/dist/commands/sync.js
+async function syncCommand(input) {
+  return fetch(`${input.config.apiBaseUrl}/api/cli/field-manifest/sync`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${input.config.accessToken}`,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      siteId: input.config.siteId,
+      manifest: input.manifest
+    })
+  });
+}
+
+// ../cli/dist/manifest/write-manifest.js
+import { mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2, join as join3 } from "path";
+export {
+  backfillCommand,
+  checkCommand,
+  exportCommand,
+  initCommand,
+  scanCommand,
+  syncCommand
+};