@wix/himalaya-cli 0.1430.0 → 0.1431.0

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/data-resources/src/base44/ownership.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Ownership and validation for an app's declared Base44 entities and functions — the Base44
+ * sibling of `../ownership.ts` (#4557).
+ *
+ * An entity is OWNED (declared by `name`, physically `Himi<AppPascal><name>`, himi's to create
+ * and seed) or ADOPTED (declared by `base44Name`, the Base44 app's own entity, read-only to
+ * himi). The CMS `himi_<app>_` prefix cannot work here: Base44 entity names are alphanumeric
+ * only, so the namespace is a PascalCase prefix instead.
+ */
+import { BASE44_BUILTIN_FIELDS, BASE44_FIELD_TYPES, BASE44_STRING_FORMATS, type Base44EntitiesConfig, type Base44EntitySpec, type Base44FunctionSpec } from "./schema.js";
+export { BASE44_BUILTIN_FIELDS, BASE44_FIELD_TYPES, BASE44_STRING_FORMATS };
+export type { Base44EntitiesConfig, Base44EntitySpec, Base44FieldSpec, Base44FieldType, Base44FunctionSpec, Base44StringFormat, } from "./schema.js";
+/** The stable machine codes `validateBase44Entities` emits. Never rename one: callers branch on it. */
+export type Base44RuleCode = "shape-invalid" | "entity-name-invalid" | "entity-owned-and-adopted" | "entity-neither-owned-nor-adopted" | "entity-duplicate" | "field-builtin" | "field-duplicate" | "field-type-unsupported" | "field-format-invalid" | "display-field-unknown" | "required-unknown" | "seed-on-adopted" | "seed-key-unknown" | "function-name-invalid" | "function-owned-and-adopted" | "function-neither-owned-nor-adopted" | "function-duplicate" | "adopted-in-owned-namespace" | "read-rule-user-scoped";
+export interface Base44Issue {
+    severity: "error" | "warning";
+    message: string;
+    ruleCode: Base44RuleCode;
+    /** The entity (or function) the issue is about, as declared. Absent for block-level issues. */
+    entity?: string;
+}
+/**
+ * `Himi` + the app slug in PascalCase: each `[A-Za-z0-9]+` run gets an upper-case first letter
+ * (`video-courses` → `HimiVideoCourses`, `com.acme.todo` → `HimiComAcmeTodo`). Everything else
+ * is dropped, so the prefix is always alphanumeric.
+ */
+export declare function base44Prefix(app: string): string;
+export declare function isAdoptedEntity(spec: Base44EntitySpec): boolean;
+export declare function isOwnedEntity(spec: Base44EntitySpec): boolean;
+/** The entity name the Base44 app actually stores: `base44Name` verbatim, or the prefixed owned name. */
+export declare function physicalEntityName(spec: Base44EntitySpec, app: string): string;
+export declare function isOwnedFunction(spec: Base44FunctionSpec): boolean;
+export declare function physicalFunctionName(spec: Base44FunctionSpec): string;
+/**
+ * Lint a `base44` block. Non-throwing: every finding is returned, each with a stable `ruleCode`.
+ * `defineApp` throws on the first `error`; `himi validate` reports them all.
+ */
+export declare function validateBase44Entities(cfg: Base44EntitiesConfig | undefined, app: string): Base44Issue[];

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/data-resources/src/base44/schema.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Declarations for the Base44 entities and backend functions an app depends on — the Base44
+ * sibling of the CMS block in `../schema.ts` (#4557).
+ *
+ * A sibling, not a union: Base44 entities are JSON Schema objects (`string`/`number`/… with a
+ * `format`), their access rules are verbatim Base44 RLS documents, and names are alphanumeric
+ * only. Folding them into `cms` would make every CMS check branch on the backend.
+ */
+export declare const BASE44_FIELD_TYPES: readonly ["string", "number", "integer", "boolean", "array", "object"];
+export type Base44FieldType = (typeof BASE44_FIELD_TYPES)[number];
+export declare const BASE44_STRING_FORMATS: readonly ["date", "date-time", "time", "email", "uri", "uuid", "file", "richtext"];
+export type Base44StringFormat = (typeof BASE44_STRING_FORMATS)[number];
+/** Fields Base44 adds to every row. Declaring one is refused: the platform owns them. */
+export declare const BASE44_BUILTIN_FIELDS: readonly ["id", "created_date", "updated_date", "created_by", "created_by_id"];
+export interface Base44FieldSpec {
+    /** The JSON Schema property name. */
+    key: string;
+    type: Base44FieldType;
+    /** Strings only. */
+    format?: Base44StringFormat;
+    enum?: (string | number)[];
+    default?: unknown;
+    /** Arrays only. */
+    items?: {
+        type: Base44FieldType;
+    };
+    description?: string;
+    /** Field-level security, the verbatim Base44 rule. */
+    rls?: {
+        read?: unknown;
+        write?: unknown;
+    };
+}
+export interface Base44EntitySpec {
+    /** OWNED: a logical PascalCase name. The physical entity is `Himi<AppPascal><name>`. */
+    name?: string;
+    /** ADOPTED: the Base44 app's own entity, verbatim. Read-only to himi. */
+    base44Name?: string;
+    title?: string;
+    displayField?: string;
+    fields: Base44FieldSpec[];
+    required?: string[];
+    /** Row-level security, the verbatim Base44 rule. */
+    rls?: {
+        create?: unknown;
+        read?: unknown;
+        update?: unknown;
+        delete?: unknown;
+        write?: unknown;
+    };
+    /** Owned entities only. Consumed by provisioning (seed) and hermetic mocks. */
+    seed?: Record<string, unknown>[];
+}
+export interface Base44FunctionSpec {
+    /** OWNED: source under `base44/functions/<name>/`. */
+    name?: string;
+    /** ADOPTED: an existing backend function, invoke-only. */
+    base44Name?: string;
+    description?: string;
+}
+/** The declarative half of `defineApp({ base44 })`. */
+export interface Base44EntitiesConfig {
+    entities?: Base44EntitySpec[];
+    functions?: Base44FunctionSpec[];
+}

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/data-resources/src/schema.d.ts

@@ -114,3 +114,4 @@ export declare const KV_DEFAULT_MAX_ENTRIES = 10000;
 export declare const KV_DEFAULT_MAX_VALUE_BYTES: number;
 export declare const KV_MAX_VALUE_BYTES: number;
 export declare const KV_MAX_TTL_SECONDS: number;
+export * from "./base44/ownership.js";

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/ts/src/base44-entities.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Base44 entity + function declarations for `defineApp({ base44: { entities, functions } })`.
+ *
+ * The ownership and validation contract lives in @himalaya/data-resources/base44 so the
+ * authoring CLI (`himi validate`, `himi base44 adopt|entities`) and `defineApp` enforce the
+ * same rules. See docs/base44-entities.md.
+ */
+export { BASE44_BUILTIN_FIELDS, BASE44_FIELD_TYPES, BASE44_STRING_FORMATS, base44Prefix, isAdoptedEntity, isOwnedEntity, physicalEntityName, validateBase44Entities, type Base44EntitySpec, type Base44FieldSpec, type Base44FieldType, type Base44FunctionSpec, type Base44Issue, type Base44RuleCode, type Base44StringFormat, } from "@wix/himalaya/data-resources";

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/ts/src/define-app.d.ts

@@ -6,11 +6,14 @@ import { type LocaleConfig } from "./locale.js";
 import { type DistributionConfig } from "./distribution.js";
 import type { CmsConfig } from "./cms.js";
 import { type DataResourcesConfig } from "@wix/himalaya/data-resources";
+import { type Base44EntitySpec, type Base44FunctionSpec } from "./base44-entities.js";
 import type { FunctionDefinition, FunctionScheduleRecord } from "@himalaya/functions";
 export type { CmsConfig, CmsCollectionSpec, CmsFieldSpec, WixFieldType } from "./cms.js";
 export type { PushRoute, PushPayloadAdapter, PushScreenMapEntry };
 export type { DataResourcesConfig, KvSpec, ResourceEnvironment, ResourceScope } from "@wix/himalaya/data-resources";
 export { WIX_FIELD_TYPES } from "./cms.js";
+export type { Base44EntitySpec, Base44FieldSpec, Base44FieldType, Base44FunctionSpec, Base44Issue, Base44RuleCode, Base44StringFormat } from "./base44-entities.js";
+export { BASE44_BUILTIN_FIELDS, BASE44_FIELD_TYPES, BASE44_STRING_FORMATS, physicalEntityName, validateBase44Entities } from "./base44-entities.js";
 /** Wix site/environment binding used by the server-function surface. */
 export interface SiteBindingConfig {
     siteId: string;
@@ -776,6 +779,15 @@ export interface Base44Config {
     appId: string;
     /** Base44 API origin. Absent ⇒ `https://base44.app`. */
     serverUrl?: string;
+    /**
+     * The Base44 entities this app depends on (#4557). Each is OWNED (`name`, physically
+     * `Himi<AppPascal><name>`) or ADOPTED (`base44Name`, the Base44 app's own entity, read-only to
+     * himi). Linted by `himi validate`; `himi base44 adopt` writes adopted entries from a book.
+     * See docs/base44-entities.md.
+     */
+    entities?: Base44EntitySpec[];
+    /** The backend functions this app invokes — owned (`name`) or adopted (`base44Name`). */
+    functions?: Base44FunctionSpec[];
 }
 export interface ServerUrls {
     screen: string;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/core.mjs

@@ -445,9 +445,9 @@ var require_codegen = __commonJS({
       }
     };
     var Label = class extends Node {
-      constructor(label) {
+      constructor(label2) {
         super();
-        this.label = label;
+        this.label = label2;
         this.names = {};
       }
       render({ _n }) {
@@ -455,14 +455,14 @@ var require_codegen = __commonJS({
       }
     };
     var Break = class extends Node {
-      constructor(label) {
+      constructor(label2) {
         super();
-        this.label = label;
+        this.label = label2;
         this.names = {};
       }
       render({ _n }) {
-        const label = this.label ? ` ${this.label}` : "";
-        return `break${label};` + _n;
+        const label2 = this.label ? ` ${this.label}` : "";
+        return `break${label2};` + _n;
       }
     };
     var Throw = class extends Node {
@@ -874,12 +874,12 @@ var require_codegen = __commonJS({
         return this._endBlockNode(For);
       }
       // `label` statement
-      label(label) {
-        return this._leafNode(new Label(label));
+      label(label2) {
+        return this._leafNode(new Label(label2));
       }
       // `break` statement
-      break(label) {
-        return this._leafNode(new Break(label));
+      break(label2) {
+        return this._leafNode(new Break(label2));
       }
       // `return` statement
       return(value) {
@@ -7143,6 +7143,170 @@ function validateDistribution(d, where = "distribution") {
   }
 }
 
+// ../../core/data-resources/src/base44/schema.ts
+var BASE44_FIELD_TYPES = ["string", "number", "integer", "boolean", "array", "object"];
+var BASE44_STRING_FORMATS = ["date", "date-time", "time", "email", "uri", "uuid", "file", "richtext"];
+var BASE44_BUILTIN_FIELDS = ["id", "created_date", "updated_date", "created_by", "created_by_id"];
+
+// ../../core/data-resources/src/base44/ownership.ts
+function base44Prefix(app) {
+  const runs = app.match(/[A-Za-z0-9]+/g) ?? [];
+  return `Himi${runs.map((r) => r.charAt(0).toUpperCase() + r.slice(1)).join("")}`;
+}
+function nonEmpty(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function isAdoptedEntity(spec) {
+  return nonEmpty(spec.base44Name);
+}
+function physicalEntityName(spec, app) {
+  if (isAdoptedEntity(spec)) return spec.base44Name;
+  return nonEmpty(spec.name) ? `${base44Prefix(app)}${spec.name}` : "";
+}
+var ENTITY_NAME = /^[A-Za-z][A-Za-z0-9]*$/;
+var FUNCTION_NAME = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+function label(spec) {
+  if (nonEmpty(spec.base44Name)) return spec.base44Name;
+  if (nonEmpty(spec.name)) return spec.name;
+  return "<unnamed>";
+}
+function userScoped(rule) {
+  if (rule === void 0) return false;
+  try {
+    return (JSON.stringify(rule) ?? "").includes("{{user.");
+  } catch {
+    return false;
+  }
+}
+function validateBase44Entities(cfg, app) {
+  if (!cfg) return [];
+  const issues = [];
+  const add = (severity, ruleCode, entity, message) => issues.push({ severity, ruleCode, message, ...entity !== void 0 ? { entity } : {} });
+  const err = (ruleCode, entity, message) => add("error", ruleCode, entity, message);
+  const prefix = base44Prefix(app);
+  const types = new Set(BASE44_FIELD_TYPES);
+  const formats = new Set(BASE44_STRING_FORMATS);
+  const builtins = new Set(BASE44_BUILTIN_FIELDS);
+  if (cfg.entities !== void 0 && !Array.isArray(cfg.entities)) err("shape-invalid", void 0, "base44.entities must be an array");
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of Array.isArray(cfg.entities) ? cfg.entities : []) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+      err("shape-invalid", void 0, "every base44 entity declaration must be an object");
+      continue;
+    }
+    const spec = raw;
+    const name = label(spec);
+    const rawName = spec.name;
+    const rawAdopted = spec.base44Name;
+    const hasName = rawName !== void 0;
+    const hasAdopted = rawAdopted !== void 0;
+    if (hasName && hasAdopted) {
+      err("entity-owned-and-adopted", name, "declare either `name` (owned) or `base44Name` (adopted), not both");
+    } else if (!hasName && !hasAdopted) {
+      err("entity-neither-owned-nor-adopted", name, "needs `name` (owned, namespaced) or `base44Name` (adopted, an entity the Base44 app already has)");
+    } else {
+      const value = hasName ? rawName : rawAdopted;
+      if (typeof value !== "string" || !ENTITY_NAME.test(value)) {
+        err("entity-name-invalid", name, `entity ${hasName ? "name" : "base44Name"} ${JSON.stringify(value)} must be alphanumeric and start with a letter \u2014 Base44 entity names allow nothing else`);
+      } else if (hasAdopted && value.startsWith(prefix)) {
+        err("adopted-in-owned-namespace", name, `adopted entity "${value}" starts with this app's owned prefix "${prefix}" \u2014 himi would treat a foreign entity as its own. Declare it with \`name\` if himi owns it, or rename it.`);
+      }
+    }
+    const physical = physicalEntityName(spec, app);
+    if (physical) {
+      if (seen.has(physical)) err("entity-duplicate", name, `duplicate entity "${physical}"`);
+      seen.add(physical);
+    }
+    const keys = /* @__PURE__ */ new Set();
+    if (!Array.isArray(spec.fields)) {
+      err("shape-invalid", name, "`fields` must be an array");
+    } else {
+      for (const rawField of spec.fields) {
+        if (!rawField || typeof rawField !== "object" || Array.isArray(rawField)) {
+          err("shape-invalid", name, "every field declaration must be an object");
+          continue;
+        }
+        const field = rawField;
+        if (typeof field.key !== "string" || !field.key) {
+          err("shape-invalid", name, "every field needs a string `key`");
+          continue;
+        }
+        if (builtins.has(field.key)) {
+          err("field-builtin", name, `field "${field.key}" is built in \u2014 Base44 adds ${BASE44_BUILTIN_FIELDS.join(", ")} to every row. Remove it from the declaration.`);
+          continue;
+        }
+        if (keys.has(field.key)) err("field-duplicate", name, `duplicate field key "${field.key}"`);
+        keys.add(field.key);
+        if (!types.has(field.type)) err("field-type-unsupported", name, `field "${field.key}" has unsupported type ${JSON.stringify(field.type)} \u2014 supported: ${BASE44_FIELD_TYPES.join(", ")}`);
+        if (field.format !== void 0) {
+          if (field.type !== "string") err("field-format-invalid", name, `field "${field.key}" declares a format but only string fields take one`);
+          else if (!formats.has(field.format)) err("field-format-invalid", name, `field "${field.key}" has unsupported format ${JSON.stringify(field.format)} \u2014 supported: ${BASE44_STRING_FORMATS.join(", ")}`);
+        }
+        if (field.items !== void 0 && (field.type !== "array" || !types.has(field.items?.type))) {
+          err("field-type-unsupported", name, field.type !== "array" ? `field "${field.key}" declares \`items\` but only array fields take one` : `field "${field.key}" has unsupported items type ${JSON.stringify(field.items?.type)} \u2014 supported: ${BASE44_FIELD_TYPES.join(", ")}`);
+        }
+      }
+    }
+    if (spec.displayField !== void 0 && !keys.has(spec.displayField) && !builtins.has(spec.displayField)) {
+      err("display-field-unknown", name, `displayField "${spec.displayField}" is not one of the declared fields (${[...keys].join(", ") || "none"})`);
+    }
+    if (spec.required !== void 0) {
+      if (!Array.isArray(spec.required)) err("shape-invalid", name, "`required` must be an array of field keys");
+      else for (const key of spec.required) {
+        if (!keys.has(key)) err("required-unknown", name, `required field "${key}" is not declared`);
+      }
+    }
+    if (spec.seed !== void 0) {
+      if (hasAdopted) {
+        err("seed-on-adopted", name, "an adopted entity cannot declare `seed` \u2014 himi never writes to entities it does not own");
+      } else if (!Array.isArray(spec.seed)) {
+        err("shape-invalid", name, "seed must be an array of row objects");
+      } else {
+        spec.seed.forEach((row, index) => {
+          if (!row || typeof row !== "object" || Array.isArray(row)) {
+            err("shape-invalid", name, `seed row ${index} must be an object`);
+            return;
+          }
+          for (const key of Object.keys(row)) {
+            if (!keys.has(key)) err("seed-key-unknown", name, `seed row ${index} sets undeclared field "${key}"`);
+          }
+        });
+      }
+    }
+    if (userScoped(spec.rls?.read)) {
+      add("warning", "read-rule-user-scoped", name, "rls.read is scoped to the signed-in user ({{user.\u2026}}), so a signed-out viewer sees an empty list. Gate the screen behind a sign-in, or widen the read rule if the rows are public.");
+    }
+  }
+  if (cfg.functions !== void 0 && !Array.isArray(cfg.functions)) err("shape-invalid", void 0, "base44.functions must be an array");
+  const seenFns = /* @__PURE__ */ new Set();
+  for (const raw of Array.isArray(cfg.functions) ? cfg.functions : []) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+      err("shape-invalid", void 0, "every base44 function declaration must be an object");
+      continue;
+    }
+    const spec = raw;
+    const name = label(spec);
+    const hasName = spec.name !== void 0;
+    const hasAdopted = spec.base44Name !== void 0;
+    if (hasName && hasAdopted) {
+      err("function-owned-and-adopted", name, "declare either `name` (owned) or `base44Name` (adopted), not both");
+      continue;
+    }
+    if (!hasName && !hasAdopted) {
+      err("function-neither-owned-nor-adopted", name, "needs `name` (owned, source under base44/functions/<name>/) or `base44Name` (adopted, an existing backend function)");
+      continue;
+    }
+    const value = hasName ? spec.name : spec.base44Name;
+    if (typeof value !== "string" || !FUNCTION_NAME.test(value)) {
+      err("function-name-invalid", name, `function name ${JSON.stringify(value)} must be letters, digits, "-" or "_"`);
+      continue;
+    }
+    if (seenFns.has(value)) err("function-duplicate", name, `duplicate function "${value}"`);
+    seenFns.add(value);
+  }
+  return issues;
+}
+
 // ../../core/data-resources/src/schema.ts
 var WIX_FIELD_TYPES = [
   "TEXT",
@@ -7492,6 +7656,14 @@ function validateLadderConfig(config) {
     );
   }
 }
+var SLUG_DEPENDENT_BASE44_RULES = /* @__PURE__ */ new Set(["adopted-in-owned-namespace", "entity-duplicate"]);
+function sameKindBase44Duplicate(entities) {
+  const list = Array.isArray(entities) ? entities.filter((e) => e && typeof e === "object") : [];
+  const firstDup = (xs) => xs.find((x, i) => xs.indexOf(x) !== i);
+  const adopted = list.map((e) => e.base44Name).filter((n) => typeof n === "string" && n !== "");
+  const owned = list.filter((e) => !e.base44Name).map((e) => e.name).filter((n) => typeof n === "string" && n !== "");
+  return firstDup(owned) ?? firstDup(adopted);
+}
 function validateBase44Config(config) {
   const b = config.base44;
   if (!b || typeof b.appId !== "string" || !/^[A-Za-z0-9]{8,64}$/.test(b.appId)) {
@@ -7503,6 +7675,12 @@ function validateBase44Config(config) {
   if (!config.capabilities?.includes("base44")) {
     throw new Error('defineApp: base44 is configured but the "base44" capability is not declared.');
   }
+  const first = validateBase44Entities({ entities: b.entities, functions: b.functions }, config.id).find((i) => i.severity === "error" && !SLUG_DEPENDENT_BASE44_RULES.has(i.ruleCode));
+  if (first) {
+    throw new Error(`defineApp: base44.entities: ${first.entity ? `"${first.entity}": ` : ""}${first.message} (${first.ruleCode})`);
+  }
+  const dup = sameKindBase44Duplicate(b.entities);
+  if (dup) throw new Error(`defineApp: base44.entities: "${dup}": duplicate entity "${dup}" (entity-duplicate)`);
 }
 function validateConfigShape(config) {
   if (!config.id || !/^[a-z0-9.]+$/.test(config.id)) {
@@ -7890,7 +8068,7 @@ function tonalElevationAlpha(level) {
 var BUTTON_SIZES = ["sm", "md", "lg"];
 var BUTTON_MIN_HIT_TARGET = 44;
 var nonNegative = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : void 0;
-var nonEmpty = (v) => typeof v === "string" && v !== "" ? v : void 0;
+var nonEmpty2 = (v) => typeof v === "string" && v !== "" ? v : void 0;
 var own = (o, k) => o && typeof o === "object" && Object.prototype.hasOwnProperty.call(o, k) ? o[k] : void 0;
 function resolveButtonTokens(tokens, size, style) {
   const button = own(own(tokens, "controls"), "button");
@@ -7904,12 +8082,12 @@ function resolveButtonTokens(tokens, size, style) {
   set("height", nonNegative(own(s, "height")));
   set("paddingH", nonNegative(own(s, "paddingH")));
   set("paddingV", nonNegative(own(s, "paddingV")));
-  set("text", nonEmpty(own(s, "text")));
+  set("text", nonEmpty2(own(s, "text")));
   set("icon", nonNegative(own(s, "icon")));
   set("radius", nonNegative(own(v, "radius")) ?? nonNegative(own(s, "radius")));
-  set("fill", nonEmpty(own(v, "fill")));
-  set("label", nonEmpty(own(v, "label")));
-  set("border", nonEmpty(own(v, "border")));
+  set("fill", nonEmpty2(own(v, "fill")));
+  set("label", nonEmpty2(own(v, "label")));
+  set("border", nonEmpty2(own(v, "border")));
   set("borderWidth", nonNegative(own(v, "borderWidth")));
   return out;
 }
@@ -9522,16 +9700,16 @@ function shouldRevealError(args) {
       return args.touched && !args.focused;
   }
 }
-var nonEmpty2 = (type) => (v) => typeof v === "string" && v.length > 0 && isValid({ type }, v);
+var nonEmpty3 = (type) => (v) => typeof v === "string" && v.length > 0 && isValid({ type }, v);
 var validators = {
   // validates: these are top-level CALLS, which esbuild otherwise has to assume
   // might have side effects — and keeping them retained `validate` and every
   // predicate behind it, DOUBLING a Tier-5 bundle that does no validation at all.
-  email: /* @__PURE__ */ nonEmpty2("email"),
-  phone: /* @__PURE__ */ nonEmpty2("phone"),
-  url: /* @__PURE__ */ nonEmpty2("url"),
-  number: /* @__PURE__ */ nonEmpty2("number"),
-  integer: /* @__PURE__ */ nonEmpty2("integer")
+  email: /* @__PURE__ */ nonEmpty3("email"),
+  phone: /* @__PURE__ */ nonEmpty3("phone"),
+  url: /* @__PURE__ */ nonEmpty3("url"),
+  number: /* @__PURE__ */ nonEmpty3("number"),
+  integer: /* @__PURE__ */ nonEmpty3("integer")
 };
 function validateAll(rules, values, catalog) {
   const errors = {};
@@ -9599,9 +9777,9 @@ var WATCH_UNAVAILABLE = {
 };
 var CAR_TEMPLATES = ["list"];
 var PROJECTION_SNAPSHOT_SIZE = "large";
-var widgetSurface = (family, label, width, height, platformKey = null) => ({
+var widgetSurface = (family, label2, width, height, platformKey = null) => ({
   id: `widget:${family}`,
-  label,
+  label: label2,
   chassis: "widget",
   viewport: { width, height },
   orientations: ["portrait"],
@@ -13825,9 +14003,9 @@ function normalizeSiteMenu(payload, site) {
   for (const item of items.slice(0, SITE_MENU_RAW_ITEMS_MAX)) {
     if (out.length >= SITE_MENU_MAX_ITEMS) break;
     if (!item || typeof item !== "object") continue;
-    const { label, href } = item;
-    if (typeof label !== "string" || typeof href !== "string") continue;
-    const clean = cleanSiteMenuLabel(label);
+    const { label: label2, href } = item;
+    if (typeof label2 !== "string" || typeof href !== "string") continue;
+    const clean = cleanSiteMenuLabel(label2);
     if (!clean) continue;
     const path = siteMenuPath(href, site.origins);
     if (path === null) continue;
@@ -13950,7 +14128,10 @@ export {
   ALL_ORIENTATIONS,
   APP_ID_PATTERN,
   AppRegistryClient,
+  BASE44_BUILTIN_FIELDS,
+  BASE44_FIELD_TYPES,
   BASE44_ORIGINS,
+  BASE44_STRING_FORMATS,
   BUTTON_LEGACY_STYLES,
   BUTTON_MIN_HIT_TARGET,
   BUTTON_SIZES,
@@ -14075,6 +14256,7 @@ export {
   normalizeSiteMenu,
   normalizeSiteOrigin,
   parseNumeric,
+  physicalEntityName,
   primarySubtag,
   resolveAppIdentity,
   resolveAppLocale,
@@ -14121,6 +14303,7 @@ export {
   tonalElevationAlpha,
   validate,
   validateAll,
+  validateBase44Entities,
   validateDistribution,
   validateLaunchManifest,
   validateMediaPlayerProps,