@almadar/core 10.129.0 → 11.0.1

package/dist/chunk-FGT5OS2Y.js

@@ -0,0 +1,918 @@
+import { SExprListSchema, SExprSchema, SExprDataSchema } from './chunk-347APWFM.js';
+import { EntityIdSchema } from './chunk-VG7BRFUD.js';
+import { JsonValueSchema } from './chunk-7GHJU5WI.js';
+import { z } from 'zod';
+
+var FieldProjectionSchema = z.object({
+  type: z.string().min(1),
+  field: z.string().min(1).optional()
+});
+var NUM_WIDTH_TAGS = ["i8", "i16", "i32", "u8", "u16", "u32", "u64", "f32"];
+var FIELD_TYPES = [
+  "string",
+  "number",
+  "int",
+  ...NUM_WIDTH_TAGS,
+  "boolean",
+  "date",
+  "timestamp",
+  "datetime",
+  "instant",
+  "email",
+  "url",
+  "phone",
+  "uuid",
+  "image",
+  "money",
+  "file",
+  "bytes",
+  "array",
+  "object",
+  "enum",
+  "relation",
+  "trait",
+  "orbital",
+  "behavior",
+  "slot",
+  "pattern",
+  "node",
+  "event",
+  "EventAddress",
+  "CallKey",
+  "SExpr",
+  "union",
+  "tuple",
+  "field"
+];
+var SEMANTIC_STRING_TYPES = ["email", "url", "phone", "uuid", "image"];
+function isSemanticStringType(type) {
+  return SEMANTIC_STRING_TYPES.includes(type);
+}
+var FieldTagSchema = z.enum(FIELD_TYPES);
+function isTypeVariable(type) {
+  return /^\$.+$/.test(type);
+}
+var TypeVariableSchema = z.custom(
+  (v) => typeof v === "string" && isTypeVariable(v),
+  { message: "a type variable is `$<name>`" }
+);
+var FieldTypeSchema = z.union([FieldTagSchema, TypeVariableSchema]);
+var TYPE_POSITION_ONLY = [
+  "Map",
+  "any",
+  "asset",
+  "bool",
+  "component",
+  "duration",
+  "entity",
+  "f64",
+  "float",
+  "i64",
+  "icon",
+  "null",
+  "secret",
+  "void"
+];
+var RelationCardinalitySchema = z.enum([
+  "one",
+  "many",
+  "one-to-many",
+  "many-to-one",
+  "many-to-many"
+]);
+var RelationConfigSchema = z.object({
+  entity: z.string().min(1, "Target entity is required"),
+  entityId: EntityIdSchema.optional(),
+  field: z.string().optional(),
+  cardinality: RelationCardinalitySchema.optional(),
+  onDelete: z.enum(["cascade", "nullify", "restrict"]).optional(),
+  display: z.string().min(1).optional(),
+  // Legacy compatibility fields
+  foreignKey: z.string().optional(),
+  target: z.string().optional(),
+  type: RelationCardinalitySchema.optional()
+}).transform((data) => {
+  const cardinality = data.cardinality || data.type;
+  const normalized = {
+    entity: data.entity || data.target || "",
+    ...data.entityId !== void 0 ? { entityId: data.entityId } : {},
+    ...cardinality !== void 0 ? { cardinality } : {},
+    ...data.field !== void 0 ? { field: data.field } : {},
+    ...data.onDelete !== void 0 ? { onDelete: data.onDelete } : {},
+    ...data.display !== void 0 ? { display: data.display } : {}
+  };
+  return normalized;
+});
+var SEMANTIC_STRING_PATTERNS = {
+  email: "^[^\\s@]+@[^\\s@.]+\\.[^\\s@]+$",
+  url: "^https?://[^\\s]+$",
+  phone: "^[+]?[\\d\\s().-]{7,}$",
+  uuid: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
+};
+var EMAIL_RE = new RegExp(SEMANTIC_STRING_PATTERNS.email);
+var URL_RE = new RegExp(SEMANTIC_STRING_PATTERNS.url);
+var PHONE_RE = new RegExp(SEMANTIC_STRING_PATTERNS.phone);
+var UUID_RE = new RegExp(SEMANTIC_STRING_PATTERNS.uuid);
+function isEmailValue(value) {
+  return EMAIL_RE.test(value);
+}
+function isUrlValue(value) {
+  return URL_RE.test(value);
+}
+function isPhoneValue(value) {
+  return PHONE_RE.test(value);
+}
+function isUuidValue(value) {
+  return UUID_RE.test(value);
+}
+var FileValueSchema = z.object({
+  name: z.string(),
+  url: z.string(),
+  mimeType: z.string(),
+  sizeBytes: z.number()
+});
+function isFileValue(value) {
+  return FileValueSchema.safeParse(value).success;
+}
+function isSemanticStringValue(type, value) {
+  switch (type) {
+    case "email":
+      return isEmailValue(value);
+    case "url":
+    case "image":
+      return isUrlValue(value);
+    case "phone":
+      return isPhoneValue(value);
+    case "uuid":
+      return isUuidValue(value);
+  }
+}
+function isTypeVariableField(f) {
+  return isTypeVariable(f.type);
+}
+var FIELD_TYPE_ALIASES = {
+  text: "string",
+  float: "number",
+  ts: "timestamp"
+};
+var EntityFieldSchema = z.lazy(() => {
+  const baseFieldShape = {
+    name: z.string().min(1, "Field name is required").optional(),
+    required: z.boolean().optional(),
+    nullable: z.boolean().optional(),
+    additionalProperties: EntityFieldSchema.optional(),
+    primaryKey: z.boolean().optional(),
+    default: JsonValueSchema.optional(),
+    min: z.number().optional(),
+    max: z.number().optional(),
+    properties: z.record(z.string(), EntityFieldSchema).optional(),
+    intrinsic: z.boolean().optional(),
+    derived: JsonValueSchema.optional(),
+    description: z.string().optional(),
+    synonyms: z.string().optional(),
+    mock: z.string().optional(),
+    mergedFrom: z.string().optional(),
+    projectedFrom: FieldProjectionSchema.optional()
+  };
+  function scalarVariant(t) {
+    return z.object({
+      ...baseFieldShape,
+      type: z.literal(t),
+      values: z.array(z.string()).optional()
+    });
+  }
+  return z.preprocess(
+    (input) => {
+      if (input === null || typeof input !== "object" || !("type" in input) || typeof input.type !== "string") {
+        return input;
+      }
+      const obj = input;
+      const next = { ...obj };
+      const aliased = FIELD_TYPE_ALIASES[obj.type];
+      if (aliased !== void 0) next.type = aliased;
+      if (next.enum !== void 0 && next.values === void 0) {
+        next.values = next.enum;
+      }
+      delete next.enum;
+      return next;
+    },
+    z.union([
+      z.object({ ...baseFieldShape, type: TypeVariableSchema }),
+      z.discriminatedUnion("type", [
+        scalarVariant("string"),
+        scalarVariant("number"),
+        scalarVariant("int"),
+        scalarVariant("i8"),
+        scalarVariant("i16"),
+        scalarVariant("i32"),
+        scalarVariant("u8"),
+        scalarVariant("u16"),
+        scalarVariant("u32"),
+        scalarVariant("u64"),
+        scalarVariant("f32"),
+        scalarVariant("boolean"),
+        scalarVariant("date"),
+        scalarVariant("timestamp"),
+        scalarVariant("datetime"),
+        scalarVariant("instant"),
+        scalarVariant("email"),
+        scalarVariant("url"),
+        scalarVariant("phone"),
+        scalarVariant("uuid"),
+        scalarVariant("image"),
+        scalarVariant("trait"),
+        scalarVariant("orbital"),
+        scalarVariant("behavior"),
+        scalarVariant("slot"),
+        scalarVariant("pattern"),
+        scalarVariant("node"),
+        scalarVariant("event"),
+        scalarVariant("EventAddress"),
+        scalarVariant("CallKey"),
+        scalarVariant("money"),
+        scalarVariant("file"),
+        scalarVariant("bytes"),
+        scalarVariant("SExpr"),
+        // Enum variant — REQUIRES non-empty values.
+        z.object({
+          ...baseFieldShape,
+          type: z.literal("enum"),
+          values: z.array(z.string()).min(1, "Enum field requires a non-empty `values` array")
+        }),
+        // Union variant — tagged struct union; values = variant names,
+        // per-variant shapes in `properties` (absent on named recursion).
+        z.object({
+          ...baseFieldShape,
+          type: z.literal("union"),
+          values: z.array(z.string()).min(1, "Union field requires a non-empty `values` array")
+        }),
+        // Relation variant — REQUIRES relation config.
+        z.object({
+          ...baseFieldShape,
+          type: z.literal("relation"),
+          relation: RelationConfigSchema
+        }),
+        // Array variant — items optional to match relaxed TS shape.
+        z.object({
+          ...baseFieldShape,
+          type: z.literal("array"),
+          items: EntityFieldSchema.optional()
+        }),
+        // Field-reference variant — `items` is the type the named field must have.
+        z.object({
+          ...baseFieldShape,
+          type: z.literal("field"),
+          record: z.string().optional(),
+          items: EntityFieldSchema.optional()
+        }),
+        // Tuple variant — slots in `properties`, keyed by index (at least one).
+        z.object({
+          ...baseFieldShape,
+          type: z.literal("tuple"),
+          properties: z.record(z.string(), EntityFieldSchema).refine((p) => Object.keys(p).length > 0, "Tuple field requires slots in `properties`")
+        }),
+        // Object variant — fixed-key struct (`properties`) or dynamic-key
+        // map (`Map K V`, uniform value schema in `items`).
+        z.object({
+          ...baseFieldShape,
+          type: z.literal("object"),
+          items: EntityFieldSchema.optional(),
+          record: z.string().optional(),
+          values: z.array(z.string()).optional()
+        })
+      ])
+    ])
+  );
+});
+var FieldSchema = EntityFieldSchema;
+var ENTITY_ROLES = [
+  "player",
+  "enemy",
+  "npc",
+  "item",
+  "tile",
+  "projectile",
+  "effect",
+  "ui",
+  "decoration",
+  "vehicle"
+];
+var EntityRoleSchema = z.enum(ENTITY_ROLES);
+var VISUAL_STYLES = ["pixel", "vector", "hd", "1-bit", "isometric"];
+var VisualStyleSchema = z.enum(VISUAL_STYLES);
+var ASSET_DIMENSIONS = ["2d", "3d"];
+var AssetDimensionSchema = z.enum(ASSET_DIMENSIONS);
+var ASSET_ASPECTS = ["1:1", "16:9", "5:7", "8:1", "4:1", "5:3", "1:2"];
+var AssetAspectSchema = z.enum(ASSET_ASPECTS);
+var FX_KINDS = ["slash", "puff", "heal", "trap", "burst"];
+var FxKindSchema = z.enum(FX_KINDS);
+var ANIMATION_NAMES = ["idle", "walk", "skate", "jump", "fall", "attack", "hit", "death"];
+var AnimationNameSchema = z.enum(ANIMATION_NAMES);
+var SPRITE_DIRECTIONS = ["se", "sw", "ne", "nw"];
+var SpriteDirectionSchema = z.enum(SPRITE_DIRECTIONS);
+var SHEET_PROJECTIONS = ["iso", "front", "back", "top", "perspective"];
+var SheetProjectionSchema = z.enum(SHEET_PROJECTIONS);
+var AnimationDefSchema = z.object({
+  row: z.number().int().nonnegative(),
+  frames: z.number().int().positive(),
+  frameRate: z.number().positive(),
+  loop: z.boolean()
+});
+var SpriteSheetAtlasSchema = z.object({
+  unit: z.string().optional(),
+  type: z.string().optional(),
+  frameWidth: z.number().positive(),
+  frameHeight: z.number().positive(),
+  columns: z.number().int().positive(),
+  rows: z.number().int().positive(),
+  directions: z.array(SpriteDirectionSchema),
+  sheets: z.partialRecord(SpriteDirectionSchema, z.string()),
+  animations: z.record(z.string(), AnimationDefSchema),
+  projections: z.object({
+    iso: z.partialRecord(SpriteDirectionSchema, z.string()).optional(),
+    front: z.string().optional(),
+    back: z.string().optional(),
+    top: z.string().optional(),
+    perspective: z.string().optional()
+  }).optional()
+});
+var SubTextureSchema = z.object({
+  x: z.number().nonnegative(),
+  y: z.number().nonnegative(),
+  width: z.number().positive(),
+  height: z.number().positive(),
+  frameX: z.number().optional(),
+  frameY: z.number().optional(),
+  frameWidth: z.number().positive().optional(),
+  frameHeight: z.number().positive().optional()
+});
+var TextureAtlasSchema = z.object({
+  imagePath: z.string(),
+  subTextures: z.record(z.string(), SubTextureSchema)
+});
+var TilesheetSchema = z.object({
+  imagePath: z.string(),
+  tileWidth: z.number().positive(),
+  tileHeight: z.number().positive(),
+  columns: z.number().int().positive(),
+  rows: z.number().int().positive(),
+  margin: z.number().nonnegative().optional(),
+  spacing: z.number().nonnegative().optional(),
+  names: z.array(z.string()).optional()
+});
+var SemanticAssetRefSchema = z.object({
+  role: z.string().min(1),
+  category: z.string().min(1),
+  animations: z.array(z.string()).optional(),
+  style: VisualStyleSchema.optional(),
+  variant: z.string().optional(),
+  dimension: AssetDimensionSchema.optional(),
+  aspect: AssetAspectSchema.optional()
+});
+var AssetSchema = SemanticAssetRefSchema.extend({
+  url: z.string(),
+  atlas: z.string().optional(),
+  sprite: z.string().optional(),
+  name: z.string().optional(),
+  thumbnailUrl: z.string().optional(),
+  prompt: z.string().optional(),
+  choreography: z.record(z.string(), z.array(z.string())).optional(),
+  fxKind: FxKindSchema.optional()
+});
+z.object({
+  pack: z.string().min(1),
+  version: z.number().int().nonnegative(),
+  base: z.string(),
+  assets: z.record(z.string(), AssetSchema)
+});
+var AssetCatalogEntrySchema = z.object({
+  url: z.string(),
+  name: z.string(),
+  category: z.string(),
+  kind: z.enum(["image", "spritesheet", "audio", "scene", "portrait", "model", "other"]),
+  thumbnailUrl: z.string().optional(),
+  dimension: AssetDimensionSchema.optional(),
+  aspect: AssetAspectSchema.optional()
+});
+var AssetCatalogSchema = z.array(AssetCatalogEntrySchema);
+var ScenePosSchema = z.object({
+  x: z.number(),
+  y: z.number(),
+  z: z.number().optional()
+});
+var CAMERA_MODES = ["isometric", "perspective", "top-down", "front", "follow", "chase"];
+var CameraModeSchema = z.enum(CAMERA_MODES);
+var CameraSchema = z.object({
+  pos: ScenePosSchema.optional(),
+  target: ScenePosSchema.optional(),
+  zoom: z.number().optional(),
+  fov: z.number().optional(),
+  mode: CameraModeSchema.optional(),
+  azimuth: z.number().optional(),
+  elevation: z.number().optional(),
+  controls: z.boolean().optional()
+});
+function createAssetKey(role, category) {
+  return `${role}:${category}`;
+}
+function parseAssetKey(key) {
+  const parts = key.split(":");
+  if (parts.length !== 2) return null;
+  return { role: parts[0], category: parts[1] };
+}
+function getDefaultAnimationsForRole(role) {
+  switch (role) {
+    case "player":
+      return ["idle", "run", "jump", "fall", "attack", "hurt", "die"];
+    case "enemy":
+      return ["idle", "walk", "attack", "hurt", "die"];
+    case "npc":
+      return ["idle", "walk", "talk"];
+    case "item":
+      return ["idle", "collected"];
+    case "tile":
+      return ["static"];
+    case "projectile":
+      return ["fly", "hit", "expire"];
+    case "effect":
+      return ["play"];
+    case "ui":
+      return ["normal", "hover", "pressed", "disabled"];
+    case "decoration":
+      return ["idle"];
+    case "vehicle":
+      return ["idle", "move", "brake"];
+    default:
+      return ["idle"];
+  }
+}
+function validateAssetAnimations(assetRef, requiredAnimations) {
+  const provided = assetRef.animations || [];
+  const missing = requiredAnimations.filter((anim) => !provided.includes(anim));
+  return { valid: missing.length === 0, missing };
+}
+var SPRITE_SHEET_LAYOUT = {
+  frameWidth: 256,
+  frameHeight: 256,
+  columns: 8,
+  rows: 5,
+  background: "#20202E"
+};
+var DEFAULT_UNIT_ANIMATION_ROWS = [
+  { name: "idle", row: 0, frames: 4, loop: true, frameRate: 6 },
+  { name: "walk", row: 1, frames: 8, loop: true, frameRate: 10 },
+  { name: "attack", row: 2, frames: 6, loop: false, frameRate: 12 },
+  { name: "hit", row: 3, frames: 3, loop: false, frameRate: 8 },
+  { name: "death", row: 4, frames: 6, loop: false, frameRate: 8 }
+];
+function defaultUnitAtlas(sheets, opts) {
+  const directions = opts?.directions ?? SPRITE_DIRECTIONS.filter((direction) => sheets[direction] !== void 0);
+  const animations = {};
+  for (const { name, ...def } of DEFAULT_UNIT_ANIMATION_ROWS) {
+    animations[name] = def;
+  }
+  return {
+    frameWidth: SPRITE_SHEET_LAYOUT.frameWidth,
+    frameHeight: SPRITE_SHEET_LAYOUT.frameHeight,
+    columns: SPRITE_SHEET_LAYOUT.columns,
+    rows: SPRITE_SHEET_LAYOUT.rows,
+    directions,
+    sheets,
+    animations
+  };
+}
+var MANIFEST_ENTRY_KINDS = ["model", "image", "spritesheet", "audio", "json"];
+var ManifestEntryKindSchema = z.enum(MANIFEST_ENTRY_KINDS);
+var SoundEntrySchema = z.object({
+  path: z.union([z.string(), z.array(z.string())]),
+  volume: z.number().optional(),
+  loop: z.boolean().optional(),
+  poolSize: z.number().optional(),
+  autostart: z.boolean().optional(),
+  crossfade: z.boolean().optional(),
+  crossfadeDurationMs: z.number().optional()
+});
+var AudioManifestSchema = z.record(z.string(), SoundEntrySchema);
+var MANIFEST_CANVAS_AFFINITIES = ["isometric", "hex", "flat", "side", "3d", "none"];
+var ManifestCanvasAffinitySchema = z.enum(MANIFEST_CANVAS_AFFINITIES);
+var MANIFEST_SOURCE_CATALOGS = ["kenny", "kekec-assets", "iram-assets", "trait-wars-assets", "kflow-assets"];
+var ManifestSourceCatalogSchema = z.enum(MANIFEST_SOURCE_CATALOGS);
+var MANIFEST_ASSET_LICENSES = ["CC0", "proprietary"];
+var ManifestAssetLicenseSchema = z.enum(MANIFEST_ASSET_LICENSES);
+var ManifestFrameSpecSchema = z.union([
+  z.object({ kind: z.literal("iso-tile"), w: z.number(), h: z.number() }),
+  z.object({ kind: z.literal("sprite-sheet"), frame: z.number(), cols: z.number(), rows: z.number() }),
+  z.string().min(1),
+  z.null()
+]);
+var ManifestEntrySchema = z.object({
+  url: z.string(),
+  name: z.string(),
+  category: z.string(),
+  kind: ManifestEntryKindSchema,
+  width: z.number(),
+  height: z.number(),
+  canvasAffinity: ManifestCanvasAffinitySchema,
+  genreAffinity: z.array(z.string()),
+  swapClass: z.string(),
+  sourceCatalog: ManifestSourceCatalogSchema,
+  frameSpec: ManifestFrameSpecSchema,
+  license: ManifestAssetLicenseSchema.optional()
+});
+var ASSET_CATALOG_ENTRY_KINDS = [
+  "image",
+  "spritesheet",
+  "audio",
+  "scene",
+  "portrait",
+  "model",
+  "other"
+];
+var MODEL_URL_EXTENSIONS = [".glb", ".gltf"];
+var AUDIO_URL_EXTENSIONS = [".mp3", ".ogg", ".wav"];
+function urlEndsWithAny(url, extensions) {
+  const lower = url.toLowerCase();
+  return extensions.some((extension) => lower.endsWith(extension));
+}
+function deriveManifestAssetKind(entry) {
+  if (typeof entry.frameSpec === "string" || entry.frameSpec?.kind === "sprite-sheet" || entry.kind === "spritesheet") return "spritesheet";
+  if (entry.kind === "model" || urlEndsWithAny(entry.url, MODEL_URL_EXTENSIONS)) return "model";
+  if (entry.kind === "audio" || urlEndsWithAny(entry.url, AUDIO_URL_EXTENSIONS)) return "audio";
+  if (entry.kind === "image") return "image";
+  return "other";
+}
+function parseAssetAspectRatio(aspect) {
+  const [w, h] = aspect.split(":").map(Number);
+  return w / h;
+}
+var ASSET_ASPECT_RATIO_TOLERANCE = 0.01;
+function deriveManifestAssetAspect(width, height) {
+  if (width <= 0 || height <= 0) return void 0;
+  const ratio = width / height;
+  for (const aspect of ASSET_ASPECTS) {
+    const expected = parseAssetAspectRatio(aspect);
+    if (Math.abs(ratio / expected - 1) <= ASSET_ASPECT_RATIO_TOLERANCE) return aspect;
+  }
+  return void 0;
+}
+var ABSOLUTE_URL_PATTERN = /^[a-z][a-z0-9+.-]*:\/\//i;
+function resolveManifestUrl(url, cdnPrefix) {
+  if (!cdnPrefix || ABSOLUTE_URL_PATTERN.test(url)) return url;
+  const prefix = cdnPrefix.endsWith("/") ? cdnPrefix : `${cdnPrefix}/`;
+  const rest = url.startsWith("/") ? url.slice(1) : url;
+  return `${prefix}${rest}`;
+}
+function manifestToAssetCatalog(entries, opts) {
+  return entries.map((entry) => {
+    const kind = deriveManifestAssetKind(entry);
+    const dimension = entry.canvasAffinity === "3d" ? "3d" : "2d";
+    const aspect = deriveManifestAssetAspect(entry.width, entry.height);
+    const url = resolveManifestUrl(entry.url, opts?.cdnPrefix);
+    const catalogEntry = {
+      url,
+      name: entry.name,
+      category: entry.category,
+      kind,
+      dimension
+    };
+    if (aspect !== void 0) catalogEntry.aspect = aspect;
+    if (kind === "image" || kind === "spritesheet") catalogEntry.thumbnailUrl = url;
+    return catalogEntry;
+  });
+}
+var ASSET_QUERY_TYPE_PREFIX = "t:";
+var ASSET_QUERY_LABEL_PREFIX = "l:";
+function isAssetCatalogEntryKind(value) {
+  return ASSET_CATALOG_ENTRY_KINDS.some((kind) => kind === value);
+}
+function parseAssetQueryTokens(q) {
+  const tokens = q.trim().length > 0 ? q.trim().split(/\s+/) : [];
+  const textParts = [];
+  const labels = [];
+  let kind;
+  let unknownKind = false;
+  for (const token of tokens) {
+    if (token.startsWith(ASSET_QUERY_TYPE_PREFIX)) {
+      const value = token.slice(ASSET_QUERY_TYPE_PREFIX.length);
+      if (isAssetCatalogEntryKind(value)) kind = value;
+      else unknownKind = true;
+    } else if (token.startsWith(ASSET_QUERY_LABEL_PREFIX)) {
+      const value = token.slice(ASSET_QUERY_LABEL_PREFIX.length);
+      if (value.length > 0) labels.push(value);
+    } else {
+      textParts.push(token);
+    }
+  }
+  return { text: textParts.join(" "), kind, labels, unknownKind };
+}
+function parseAssetQuery(q) {
+  const parsed = parseAssetQueryTokens(q);
+  return parsed.kind === void 0 ? { text: parsed.text, labels: parsed.labels } : { text: parsed.text, kind: parsed.kind, labels: parsed.labels };
+}
+function matchAssetQuery(entry, q) {
+  const parsed = parseAssetQueryTokens(q);
+  if (parsed.unknownKind) return false;
+  if (parsed.kind !== void 0 && entry.kind !== parsed.kind) return false;
+  for (const label of parsed.labels) {
+    if (entry.category.toLowerCase() !== label.toLowerCase()) return false;
+  }
+  if (parsed.text.length > 0) {
+    const haystack = `${entry.name} ${entry.category}`.toLowerCase();
+    if (!haystack.includes(parsed.text.toLowerCase())) return false;
+  }
+  return true;
+}
+var EntityPersistenceSchema = z.enum([
+  "persistent",
+  "runtime"
+]);
+var OrbitalEntitySchema = z.object({
+  name: z.string().min(1, "Entity name is required"),
+  // V4 arena id (`EntityDefinition.id`); declared so the strip-mode zod gate
+  // carries an imported entity's id through instead of erasing it.
+  id: EntityIdSchema.optional(),
+  persistence: EntityPersistenceSchema.default("persistent"),
+  shared: z.boolean().optional(),
+  // Must stay in step with the Rust serde field (`EntityDefinition.identity`,
+  // orbital-core/src/schema/types.rs). `z.object()` STRIPS unknown keys rather
+  // than rejecting them, so a Rust-only field works on the compiled path and
+  // silently vanishes on the interpreter path.
+  identity: z.boolean().optional(),
+  // Rust twin: `EntityDefinition.browser`.
+  browser: z.boolean().optional(),
+  // Rust twin: `EntityDefinition.store`.
+  store: z.string().min(1).optional(),
+  // Same "must stay in step with Rust serde" hazard as `identity` above —
+  // these four mirror `EntityDefinition.{read,create,update,delete}_policy`.
+  // Rust has no `rename_all` on this struct, so the wire key IS snake_case
+  // (unlike this file's other camelCase fields, which are Rust-side-absent
+  // and so never hit this cross-language constraint — see `visual_prompt`
+  // just below for the existing precedent).
+  read_policy: SExprSchema.optional(),
+  create_policy: SExprSchema.optional(),
+  update_policy: SExprSchema.optional(),
+  delete_policy: SExprSchema.optional(),
+  // Snake_case for the same cross-language reason as the four policies above.
+  access_waivers: z.object({
+    read: z.string().optional(),
+    create: z.string().optional(),
+    update: z.string().optional(),
+    delete: z.string().optional()
+  }).optional(),
+  invariants: SExprListSchema.optional(),
+  indexes: z.array(z.object({ fields: z.array(z.string()), orderBy: z.string().optional() }).strict()).optional(),
+  collection: z.string().optional(),
+  fields: z.array(EntityFieldSchema),
+  instances: z.array(z.record(z.string(), JsonValueSchema)).optional(),
+  localeInstances: z.record(z.string(), z.array(z.record(z.string(), JsonValueSchema))).optional(),
+  timestamps: z.boolean().optional(),
+  softDelete: z.boolean().optional(),
+  description: z.string().optional(),
+  visual_prompt: z.string().optional(),
+  assetRef: SemanticAssetRefSchema.optional()
+});
+var EntitySchema = OrbitalEntitySchema;
+function instancesForLocale(entity, locale) {
+  const localized = locale !== void 0 ? entity.localeInstances?.[locale] : void 0;
+  return localized ?? entity.instances ?? [];
+}
+function isRuntimeEntity(entity) {
+  return entity.persistence === "runtime";
+}
+function isClientResident(entity) {
+  return entity.persistence === "runtime" || entity.browser === true;
+}
+function storesRowsInBrowser(entity) {
+  return entity.browser === true;
+}
+function persistenceModeAllowsOverrides(persistence, dataBearing = false) {
+  return persistence === "persistent" || persistence === void 0 || persistence === "runtime" && dataBearing;
+}
+var FieldValueSchema = JsonValueSchema;
+function isFieldValue(value) {
+  if (value === null) return true;
+  const kind = typeof value;
+  if (kind === "string" || kind === "number" || kind === "boolean") return true;
+  if (Array.isArray(value)) return value.every((item) => isFieldValue(item));
+  if (kind === "object" && typeof value === "object" && !(value instanceof Date)) {
+    return Object.values(value).every((item) => isFieldValue(item));
+  }
+  return false;
+}
+var EntityRowSchema = z.object({ id: z.string().optional() }).catchall(FieldValueSchema);
+var UI_SLOTS = [
+  // App slots
+  "main",
+  "sidebar",
+  "dock",
+  // Right inline panel that pushes main (narrow screens: a drawer)
+  "modal",
+  "drawer",
+  "overlay",
+  "center",
+  "toast",
+  "floating",
+  "system",
+  // For invisible system components (InputListener, CollisionDetector)
+  "content",
+  "screen",
+  // Game HUD slots
+  "hud",
+  "hud-top",
+  "hud-bottom",
+  "hud.health",
+  "hud.score",
+  "hud.inventory",
+  "hud.stamina",
+  // Game overlay slots
+  "overlay.inventory",
+  "overlay.dialogue",
+  "overlay.menu",
+  "overlay.pause"
+];
+var RENDERED_SLOTS = UI_SLOTS.filter(
+  (slot) => !slot.includes(".") && slot !== "hud" && slot !== "screen"
+);
+var UISlotSchema = z.enum(UI_SLOTS);
+function isRowObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+}
+function isPersistBatchOperation(value) {
+  if (!Array.isArray(value) || typeof value[1] !== "string") return false;
+  switch (value[0]) {
+    case "create":
+      return value.length === 2 || value.length === 3 && isRowObject(value[2]);
+    case "update":
+      return typeof value[2] === "string" && (value.length === 3 || value.length === 4 && isRowObject(value[3]));
+    case "delete":
+      return value.length === 3 && typeof value[2] === "string";
+    default:
+      return false;
+  }
+}
+var EFFECT_OPERATORS = [
+  "render-ui",
+  "navigate",
+  "navigate-back",
+  "emit",
+  "set",
+  "persist",
+  "call-service",
+  "cancel-call",
+  "oauth-authorize",
+  "oauth-connection-status",
+  "oauth-connection-forget",
+  "random-bytes",
+  "credential-status",
+  "credential-forget",
+  "credential-connect",
+  "credential-list",
+  "credential-set",
+  "credential-remove",
+  "credential-test",
+  "credential-mode",
+  "credential-rotate",
+  "access-check",
+  "spawn",
+  "despawn",
+  "do",
+  "fetch",
+  "fetch-stream",
+  "if",
+  "when",
+  "let",
+  "log",
+  "wait",
+  "notify",
+  "send-server",
+  "prob/seed",
+  "prob/condition",
+  "workspace/write-orbital",
+  "workspace/write-file",
+  "workspace/write-schema",
+  "workspace/write-plan",
+  "workspace/archive-orbital",
+  "behavior/catalog",
+  "behavior/describe",
+  "behavior/source",
+  "behavior/resolve",
+  "behavior/dependencies",
+  "behavior/packages",
+  "program/read",
+  "program/print",
+  "program/eval",
+  "program/validate",
+  "program/prove",
+  "program/os-grants",
+  "program/compose",
+  "program/step",
+  "program/inputs",
+  "program/dispatch",
+  "program/open",
+  "program/close",
+  "program/live",
+  "program/self",
+  "program/tick",
+  "program/resolve-rows",
+  "persist/read-named",
+  "mem/arena-new",
+  "mem/arena-drop",
+  "mem/alloc",
+  "mem/free",
+  "mem/borrow",
+  "mem/release",
+  "mem/write",
+  "mem/freeze",
+  "mem/atomic-load",
+  "mem/atomic-store",
+  "mem/atomic-add",
+  "mem/atomic-cas",
+  "kernel/queue-front",
+  "kernel/queue-back",
+  "ffi/call"
+];
+var EFFECT_OPERATOR_FAMILIES = [
+  "agent",
+  "os",
+  "browser",
+  "llm",
+  "session",
+  "trace",
+  "memory",
+  "kv",
+  "application",
+  "audio",
+  "auth",
+  "identity",
+  "theme"
+];
+var SERVER_REPORTED_EFFECTS = [
+  "set",
+  "persist",
+  "call-service",
+  "fetch",
+  "fetch-stream",
+  "emit"
+];
+var EffectShapeSchema = z.array(SExprDataSchema).min(1).refine(
+  (arr) => typeof arr[0] === "string",
+  { message: "Effect must be an S-expression with a string operator as first element" }
+);
+var EffectSchema = z.custom(
+  (value) => EffectShapeSchema.safeParse(value).success,
+  { message: "Effect must be an S-expression with a string operator as first element" }
+);
+function isEffect(value) {
+  return Array.isArray(value) && value.length > 0 && typeof value[0] === "string";
+}
+var isSExprEffect = isEffect;
+function set(binding, value) {
+  return ["set", binding, value];
+}
+function emit(event, payload) {
+  return payload ? ["emit", event, payload] : ["emit", event];
+}
+function navigate(path, params, options) {
+  if (params && options) return ["navigate", path, params, options];
+  return params ? ["navigate", path, params] : ["navigate", path];
+}
+function navigateBack() {
+  return ["navigate-back"];
+}
+function renderUI(target, pattern) {
+  return ["render-ui", target, pattern];
+}
+function persist(action, entity, data) {
+  if (action === "create" || action === "upsert" || action === "update") {
+    return ["persist", action, entity, data];
+  }
+  return data ? ["persist", action, entity, data] : ["persist", action, entity];
+}
+function callService(serviceName, config) {
+  return ["call-service", serviceName, config];
+}
+function spawn(entity, initialState) {
+  return initialState ? ["spawn", entity, initialState] : ["spawn", entity];
+}
+function despawn(entityId) {
+  return ["despawn", entityId];
+}
+function doEffects(...effects) {
+  return ["do", ...effects];
+}
+var PatternConfigSchema = z.custom(
+  (value) => value === null || typeof value === "object" && value !== null && !Array.isArray(value),
+  { message: "Expected a pattern config object or null" }
+);
+var PatternObjectSchema = z.custom(
+  (value) => typeof value === "object" && value !== null && !Array.isArray(value),
+  { message: "Expected a pattern config object" }
+);
+var ResolvedPatternPropsSchema = z.custom(
+  (value) => typeof value === "object" && value !== null && !Array.isArray(value),
+  { message: "Expected a resolved pattern props object" }
+);
+
+export { ANIMATION_NAMES, ASSET_ASPECTS, ASSET_DIMENSIONS, AnimationDefSchema, AnimationNameSchema, AssetAspectSchema, AssetCatalogEntrySchema, AssetCatalogSchema, AssetDimensionSchema, AssetSchema, AudioManifestSchema, CAMERA_MODES, CameraModeSchema, CameraSchema, DEFAULT_UNIT_ANIMATION_ROWS, EFFECT_OPERATORS, EFFECT_OPERATOR_FAMILIES, ENTITY_ROLES, EffectSchema, EntityFieldSchema, EntityPersistenceSchema, EntityRoleSchema, EntityRowSchema, EntitySchema, FIELD_TYPES, FX_KINDS, FieldProjectionSchema, FieldSchema, FieldTagSchema, FieldTypeSchema, FieldValueSchema, FileValueSchema, FxKindSchema, MANIFEST_ASSET_LICENSES, MANIFEST_CANVAS_AFFINITIES, MANIFEST_ENTRY_KINDS, MANIFEST_SOURCE_CATALOGS, ManifestAssetLicenseSchema, ManifestCanvasAffinitySchema, ManifestEntryKindSchema, ManifestEntrySchema, ManifestFrameSpecSchema, ManifestSourceCatalogSchema, NUM_WIDTH_TAGS, OrbitalEntitySchema, PatternConfigSchema, PatternObjectSchema, RENDERED_SLOTS, RelationConfigSchema, ResolvedPatternPropsSchema, SEMANTIC_STRING_PATTERNS, SEMANTIC_STRING_TYPES, SERVER_REPORTED_EFFECTS, SHEET_PROJECTIONS, SPRITE_DIRECTIONS, SPRITE_SHEET_LAYOUT, ScenePosSchema, SemanticAssetRefSchema, SheetProjectionSchema, SoundEntrySchema, SpriteDirectionSchema, SpriteSheetAtlasSchema, SubTextureSchema, TYPE_POSITION_ONLY, TextureAtlasSchema, TilesheetSchema, TypeVariableSchema, UISlotSchema, UI_SLOTS, VISUAL_STYLES, VisualStyleSchema, callService, createAssetKey, defaultUnitAtlas, despawn, doEffects, emit, getDefaultAnimationsForRole, instancesForLocale, isClientResident, isEffect, isEmailValue, isFieldValue, isFileValue, isPersistBatchOperation, isPhoneValue, isRuntimeEntity, isSExprEffect, isSemanticStringType, isSemanticStringValue, isTypeVariable, isTypeVariableField, isUrlValue, isUuidValue, manifestToAssetCatalog, matchAssetQuery, navigate, navigateBack, parseAssetKey, parseAssetQuery, persist, persistenceModeAllowsOverrides, renderUI, set, spawn, storesRowsInBrowser, validateAssetAnimations };
+//# sourceMappingURL=chunk-FGT5OS2Y.js.map
+//# sourceMappingURL=chunk-FGT5OS2Y.js.map