@almadar/core 10.86.0 → 10.87.0

package/dist/json-D8gmyK3l.d.ts

@@ -0,0 +1,65 @@
+/**
+ * JSON primitives — the universal "data crossed a boundary" type.
+ *
+ * Every value that arrives over the wire from an LLM (tool-call args),
+ * from disk (workspace files), or from an HTTP body before
+ * domain-specific validation is a `JsonValue`. Narrow with a typed
+ * predicate (`is`-guard) at the boundary; don't widen back to `unknown`.
+ *
+ * `JsonObject` and `ToolArgs` are aliases for the common
+ * `Record<string, JsonValue>` shape. `ToolArgs` is the name the
+ * agent surface uses for LLM-emitted tool-call arguments; `JsonObject`
+ * is the general-purpose alias. They are the same type — the alias
+ * exists so call sites read at the right semantic level.
+ *
+ * Why not `Record<string, unknown>`? Two reasons. (1) `unknown` widens
+ * back to anything, which defeats the purpose of typing the boundary.
+ * (2) The `@almadar/eslint-plugin/no-record-string-unknown` rule blocks
+ * the wider form — `JsonValue`-based records are the typed answer.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Recursive JSON value union — every shape JSON can carry.
+ */
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/**
+ * JSON object — keyed string→JsonValue. The wire form of arbitrary
+ * structured data. Replaces `Record<string, unknown>` at typed
+ * boundaries (LLM emits, file reads, HTTP bodies).
+ */
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+/**
+ * LLM tool-call arguments — same shape as `JsonObject`, named for the
+ * agent-surface call site. Each tool's `execute(args: ToolArgs)`
+ * receives this and narrows via an `is`-guard predicate before any
+ * field access.
+ */
+type ToolArgs = JsonObject;
+/**
+ * Universal type-guard input — every runtime value shape a predicate can
+ * be handed, enumerated instead of `unknown` (the repo bans `unknown`
+ * even at guard boundaries). Primitives cover every `typeof` result;
+ * `object` covers arrays, records, class instances, and functions.
+ */
+type RuntimeValue = string | number | bigint | boolean | symbol | Date | null | undefined | object;
+/**
+ * Type guard: is the given value a JSON primitive (non-array,
+ * non-object)? Used by walkers that decide whether to recurse.
+ */
+declare function isJsonPrimitive(value: JsonValue): value is string | number | boolean | null;
+/**
+ * Type guard: is the given value a JSON object (non-array, non-null)?
+ */
+declare function isJsonObject(value: JsonValue): value is JsonObject;
+/**
+ * Type guard: is the given value a JSON array?
+ */
+declare function isJsonArray(value: JsonValue): value is JsonValue[];
+
+export { type JsonValue as J, type RuntimeValue as R, type ToolArgs as T, type JsonObject as a, isJsonObject as b, isJsonPrimitive as c, isJsonArray as i };

package/dist/mock/index.d.ts

@@ -1,9 +1,10 @@
-import { O as OrbitalSchema } from '../schema-BhfQb1oe.js';
-export { E as EntityAccessPolicies, e as entityAccessPolicies, a as entityAccessPoliciesByStoreKey, b as entityAccessTable } from '../entityAccess-DK5S_2cT.js';
-import { a as EntityPersistence, E as EntityField, F as FieldValue, f as EntityRow } from '../effect-BgDiw_bG.js';
-import '../trait-pavNlGqm.js';
-import '../expression-Fk8bQWef.js';
+import { f as OrbitalEntity, a as EntityPersistence, E as EntityField, F as FieldValue, g as EntityRow } from '../effect-DMA97JxX.js';
+import { a as OrbitalDefinition, O as OrbitalSchema } from '../schema-_SPrm5Ic.js';
+import { S as SExpr } from '../expression-WfTp2arD.js';
+export { E as EntityAccessPolicies, e as entityAccessPolicies, a as entityAccessPoliciesByStoreKey, b as entityAccessTable } from '../entityAccess-DNDEF75i.js';
 import 'zod';
+import '../json-D8gmyK3l.js';
+import '../trait-9tfq2tQb.js';
 
 /**
  * Lightweight seeded pseudo-random generator for mock data.
@@ -78,7 +79,8 @@ declare function randomPhone(): string;
  */
 
 /**
- * The name of the schema's `[identity]` entity, if it declares one.
+ * The `[identity]` entities that decide what `@user` resolves to, primaries
+ * first then auxiliaries.
  *
  * A behavior declares its own roster so it runs standalone. Composing it never
  * imports that orbital, but a trait bound to one of its siblings drags the
@@ -88,16 +90,125 @@ declare function randomPhone(): string;
  * wraps one behavior inherit that behavior's roster.
  *
  * Compiled-path twin: `identity_entities` in
+ * `orbital-compiler/src/phases/validation/user_identity.rs` (L94-102).
+ */
+declare function identityEntitiesOf(orbitals: readonly OrbitalDefinition[]): OrbitalEntity[];
+/**
+ * The name of the schema's `[identity]` entity, if it declares one.
+ *
+ * Compiled-path twin: `identity_entities` in
  * `orbital-compiler/src/phases/validation/user_identity.rs`.
  */
 declare function identityEntityName(schema: OrbitalSchema): string | undefined;
 /**
- * Owner columns as `Entity.field` pairs — every relation field pointing at an
- * `[identity]`-tagged entity, shadowed imported rosters included. Empty when the
+ * Every `[identity]`-tagged name, shadowed copies included.
+ *
+ * Owner-column derivation asks whether a relation targets *a* roster, not *the*
+ * one: `Timesheet.employeeId : Employee` is an owner column whether or not
+ * `Employee` won the `@user` binding. Dropping the shadowed names here would
+ * leave an imported behavior's rows unscoped at runtime while the compiled path
+ * treats the very same column as an owner column.
+ *
+ * Compiled-path twin: `identity_entity_names` in
+ * `orbital-compiler/src/phases/validation/user_identity.rs`.
+ */
+declare function identityEntityNames(schema: OrbitalSchema): string[];
+/**
+ * The declared vocabulary for an identity field, following `items` for the
+ * array/map form. `roles : ["a" | "b"]` keeps the union on the ELEMENT, so a
+ * multi-valued role field is read through `items` — one level, not recursive.
+ *
+ * Compiled-path twin: `vocabulary` in
+ * `orbital-compiler/src/phases/validation/user_identity.rs` (L125-134).
+ */
+declare function roleVocabularyOf(entity: OrbitalEntity, field?: string): readonly string[] | undefined;
+/**
+ * Every column `expr` compares to `@user.id` via direct equality — the
+ * general form of "self-identity": `@entity.<field> == @user.id` (either
+ * operand order, either spelling — see `fieldRefName`) names `field` as an
+ * owner column, whether `field` is the row's OWN `id` (distinct from a
+ * relation column like `@entity.managerId == @user.id`) or any other
+ * declared field (the shape `ORB_S_OWNER_FIELD_NOT_IDENTITY_TYPED` flags as
+ * an authoring error when it is neither — codegen still needs to seed it).
+ * Recurses through `and`/`or`/`not`/any other combinator —
+ * `std-time-tracking`'s `Employee [identity]` declares
+ * `@read (or (= @user.role "approver") (= (object/get @entity id) @user.id))`,
+ * and the self-access arm counts even though it isn't the whole policy.
+ * Rust twin: `owner_columns_from_policy` in `orbital-core/src/runtime/seed.rs`.
+ */
+declare function ownerColumnsFromPolicy(expr: SExpr, out?: string[]): string[];
+/**
+ * Owner columns as `Entity.field` pairs — every NON-INTRINSIC relation field
+ * pointing at an `[identity]`-tagged entity, shadowed imported rosters
+ * included, PLUS `Entity.id` for an `[identity]` entity whose own declared
+ * access policy compares its row directly to the viewer (self-identity), PLUS
+ * any other column an entity's own declared `@read`/`@update`/`@delete`
+ * compares to `@user.id` (see `ownerColumnsFromPolicy`). Empty when the
  * program declares no identity, which keeps every unmigrated app behaving
  * exactly as before.
+ *
+ * An `intrinsic: true` relation field is excluded even when it targets the
+ * identity entity: intrinsic marks framework plumbing the owning trait
+ * computes itself (`EntityField.intrinsic` doc, `types/field.ts`), never
+ * domain ownership — a generic atom's self-relation (`ModalRecord.seedRow :
+ * ModalRecord`, record-detail/modal edit-seed plumbing) gets its relation
+ * target rewritten onto whatever entity the trait binds, so a self-identity
+ * entity like `std-time-tracking`'s `Employee [identity]` ends up with an
+ * `Employee.seedRow : Employee` self-relation that is structurally
+ * indistinguishable from a real owner column by type/target alone. Stamping
+ * it with the viewer id (as an owner column would be) creates a row that
+ * references itself, which trips the entity's own `onDelete: restrict`.
  */
 declare function ownerFieldsFromSchema(schema: OrbitalSchema): string[];
+/**
+ * Every literal an expression compares against `@user.<field>` (any field),
+ * keyed by field name — the collecting counterpart of `orbital-compiler`'s
+ * `validation::user_identity::check_comparison` (B4-R4; the two must stay
+ * shape-identical, each cites the other): an equality node (`EQUALITY_OPS`)
+ * or an `array/includes` node, walked transparently through `and`/`or`/`not`
+ * and any other combinator (the Rust check runs on EVERY array node
+ * regardless of what wraps it, so this does too).
+ *
+ * `array/includes` is directional, but the sigil can sit on EITHER side:
+ * `(array/includes @user.roles "ghost")` checks a literal against a
+ * multi-valued field's own vocabulary (field is the haystack, position 0);
+ * the Stage-B orbital-import role rewrite (Rust `inline/rewrite.rs`
+ * `rewrite_role_literals`, which `check_comparison` mirrors) instead
+ * produces `(array/includes ["owner","project_manager"] @user.role)` — a
+ * literal ARRAY haystack with the sigil as the needle, position 1 (found
+ * live: Project Friday's imported `Timesheet.@delete` after `roles {
+ * approver: [owner, project_manager] }`). So the sigil is located BY
+ * CONTENT, never position: check position 0 first, fall back to position 1.
+ * The OTHER side is then flattened to a literal list — a scalar (equality,
+ * or an `array/includes` whose haystack is the sigil's own multi-valued
+ * field) or, for the role-rewrite shape, every string element of a literal
+ * array.
+ *
+ * A collected literal is a CANDIDATE a viewer might satisfy the expression
+ * with, never a proof: a policy that ANDs the field check with an unrelated
+ * condition can still reject a viewer carrying it. Callers that need
+ * certainty re-check with the real evaluator (`checkMutationAccess` /
+ * `evaluate`), the way any other synthesized dispatch is confirmed.
+ */
+declare function collectUserFieldLiterals(expr: SExpr, out?: Map<string, Set<string>>): Map<string, Set<string>>;
+/**
+ * A `@user.<field>` value that satisfies `policy`, chosen from the identity
+ * entity's own declared vocabulary — never a guess: only a literal BOTH
+ * (a) compared against `field` in an equality/`array/includes` node
+ * somewhere in `policy` (see {@link collectUserFieldLiterals}) AND (b) a
+ * declared member of `identity`'s `field` vocabulary (see
+ * {@link roleVocabularyOf}) is a candidate. The pick is deterministic — the
+ * first vocabulary value, in declaration order, that is also a candidate —
+ * so two callers asking about the same policy always agree.
+ *
+ * `undefined` when `policy` is absent/`null` (no restriction — nothing to
+ * satisfy), `field` carries no declared vocabulary on `identity`, or no
+ * declared value appears anywhere in the policy. The last case is a genuine
+ * finding for the CALLER to report, not a probe defect to paper over: the
+ * policy structurally cannot be satisfied by any roster member, so forcing a
+ * viewer past it would misreport an unreachable transition as reachable.
+ */
+declare function roleSatisfyingPolicy(policy: SExpr | undefined, identity: OrbitalEntity, field?: string): string | undefined;
 
 /**
  * The one owner of mock-seed value synthesis.
@@ -152,13 +263,19 @@ declare function sampleRowCount(entity: SampleEntity, requested: number): number
 /**
  * One sample value for one field. `undefined` means OMIT the key.
  *
- * Order matters — see the three gates in the plan. Gates 1 and 2 read declared
- * schema properties (`persistence`, `intrinsic`), never field names.
+ * Order matters — see the four gates in the plan. Gates 1, 2 and 3 read
+ * declared schema properties (`persistence`, `intrinsic`, `required`,
+ * `default`, `type`), never field names.
  */
 declare function sampleFieldValue(field: EntityField, ctx: SampleContext): FieldValue | undefined;
-/** One row. Reserved keys are left to the caller. */
+/**
+ * One row. Reserved keys are left to the caller. Under `strategy: 'seeded'`,
+ * every other row (see {@link omitsUndefaultedOptionalFields}) omits its
+ * undefaulted optional fields — required/defaulted/relation fields are
+ * always present.
+ */
 declare function sampleRow(entity: SampleEntity, ctx: Omit<SampleContext, 'entityName' | 'depth'>): EntityRow;
 /** `count` rows, 1-based, honoring the runtime-singleton gate. */
 declare function sampleRows(entity: SampleEntity, count: number, strategy: SampleStrategy): EntityRow[];
 
-export { IMAGE_FIELD_NAMES, type SampleContext, type SampleEntity, type SampleStrategy, identityEntityName, isDeclaredDefaultHonored, ownerFieldsFromSchema, randomAnytimeDate, randomArrayElement, randomBoolean, randomColor, randomEmail, randomFloat, randomInt, randomPassword, randomPastDate, randomPhone, randomRecentDate, randomSentence, randomStraddlingDate, randomUrl, randomUuid, randomWords, sampleFieldValue, sampleImageUrl, sampleRow, sampleRowCount, sampleRows, seedRandom, shuffleArray };
+export { IMAGE_FIELD_NAMES, type SampleContext, type SampleEntity, type SampleStrategy, collectUserFieldLiterals, identityEntitiesOf, identityEntityName, identityEntityNames, isDeclaredDefaultHonored, ownerColumnsFromPolicy, ownerFieldsFromSchema, randomAnytimeDate, randomArrayElement, randomBoolean, randomColor, randomEmail, randomFloat, randomInt, randomPassword, randomPastDate, randomPhone, randomRecentDate, randomSentence, randomStraddlingDate, randomUrl, randomUuid, randomWords, roleSatisfyingPolicy, roleVocabularyOf, sampleFieldValue, sampleImageUrl, sampleRow, sampleRowCount, sampleRows, seedRandom, shuffleArray };

package/dist/mock/index.js

@@ -166,7 +166,7 @@ function randomPhone() {
   return `+1 (${area}) ${prefix}-${line}`;
 }
 
-// src/mock/identityOwners.ts
+// src/access/entityAccess.ts
 function inlineEntities(schema) {
   const out = [];
   for (const orbital of schema.orbitals ?? []) {
@@ -179,15 +179,74 @@ function inlineEntities(schema) {
   }
   return out;
 }
-function identityEntitiesTagged(schema) {
+function isDeclared(p) {
+  return p.read !== void 0 || p.create !== void 0 || p.update !== void 0 || p.delete !== void 0;
+}
+function entityAccessTable(schema) {
+  const table = /* @__PURE__ */ new Map();
+  const collectionOf = /* @__PURE__ */ new Map();
+  for (const def of inlineEntities(schema)) {
+    table.set(def.name, {
+      read: def.read_policy,
+      create: def.create_policy,
+      update: def.update_policy,
+      delete: def.delete_policy
+    });
+    if (def.collection) collectionOf.set(def.name, def.collection);
+  }
+  const byCollection = /* @__PURE__ */ new Map();
+  for (const [name, policies] of table) {
+    const collection = collectionOf.get(name);
+    if (collection && isDeclared(policies) && !byCollection.has(collection)) {
+      byCollection.set(collection, policies);
+    }
+  }
+  for (const [name, policies] of table) {
+    if (isDeclared(policies)) continue;
+    const collection = collectionOf.get(name);
+    const inherited = collection ? byCollection.get(collection) : void 0;
+    if (inherited) table.set(name, { ...inherited });
+  }
+  return table;
+}
+function entityAccessPolicies(schema, entityName) {
+  return entityAccessTable(schema).get(entityName);
+}
+function entityAccessPoliciesByStoreKey(schema) {
+  const collectionOf = /* @__PURE__ */ new Map();
+  for (const def of inlineEntities(schema)) {
+    if (def.collection) collectionOf.set(def.name, def.collection);
+  }
+  const byKey = /* @__PURE__ */ new Map();
+  for (const [name, policies] of entityAccessTable(schema)) {
+    const key = collectionOf.get(name) ?? name.toLowerCase();
+    if (!byKey.has(key) && isDeclared(policies)) byKey.set(key, policies);
+  }
+  return byKey;
+}
+
+// src/mock/identityOwners.ts
+function inlineEntities2(schema) {
   const out = [];
   for (const orbital of schema.orbitals ?? []) {
+    const refs = [orbital.entity, ...orbital.auxiliaryEntities ?? []];
+    for (const ref of refs) {
+      if (typeof ref === "object" && ref !== null && "fields" in ref) {
+        out.push(ref);
+      }
+    }
+  }
+  return out;
+}
+function identityEntitiesTaggedOf(orbitals) {
+  const out = [];
+  for (const orbital of orbitals) {
     const ref = orbital.entity;
     if (typeof ref === "object" && ref !== null && "fields" in ref && ref.identity === true) {
       out.push({ def: ref, primary: true });
     }
   }
-  for (const orbital of schema.orbitals ?? []) {
+  for (const orbital of orbitals) {
     for (const ref of orbital.auxiliaryEntities ?? []) {
       if (typeof ref === "object" && ref !== null && "fields" in ref && ref.identity === true) {
         out.push({ def: ref, primary: false });
@@ -196,26 +255,74 @@ function identityEntitiesTagged(schema) {
   }
   return out;
 }
+function identityEntitiesOf(orbitals) {
+  const tagged = identityEntitiesTaggedOf(orbitals);
+  const hasPrimary = tagged.some((e) => e.primary);
+  return tagged.filter((e) => e.primary || !hasPrimary).map((e) => e.def);
+}
 function identityEntityName(schema) {
-  const tagged = identityEntitiesTagged(schema);
-  return (tagged.find((e) => e.primary) ?? tagged[0])?.def.name;
+  return identityEntitiesOf(schema.orbitals ?? [])[0]?.name;
 }
 function identityEntityNames(schema) {
   const out = [];
-  for (const { def } of identityEntitiesTagged(schema)) {
+  for (const { def } of identityEntitiesTaggedOf(schema.orbitals ?? [])) {
     if (!out.includes(def.name)) out.push(def.name);
   }
   return out;
 }
+function roleVocabularyOf(entity, field = "role") {
+  const def = entity.fields.find((f) => f.name === field);
+  if (!def) return void 0;
+  return fieldVocabulary(def);
+}
+function fieldVocabulary(field) {
+  if ("values" in field && field.values && field.values.length > 0) {
+    return field.values;
+  }
+  if ("items" in field && field.items && "values" in field.items && field.items.values && field.items.values.length > 0) {
+    return field.items.values;
+  }
+  return void 0;
+}
+function fieldRefName(x, binding) {
+  if (typeof x === "string" && x.startsWith(`${binding}.`)) return x.slice(binding.length + 1);
+  if (Array.isArray(x) && x.length === 3 && x[0] === "object/get" && x[1] === binding && typeof x[2] === "string") {
+    return x[2];
+  }
+  return void 0;
+}
+function isFieldRef(x, binding, field) {
+  return fieldRefName(x, binding) === field;
+}
+var OWNER_EQ_OPS = ["=", "=="];
+function ownerColumnsFromPolicy(expr, out = []) {
+  if (Array.isArray(expr)) {
+    if (expr.length === 3) {
+      const [op, a, b] = expr;
+      if (typeof op === "string" && OWNER_EQ_OPS.includes(op)) {
+        const field = isFieldRef(b, "@user", "id") ? fieldRefName(a, "@entity") : isFieldRef(a, "@user", "id") ? fieldRefName(b, "@entity") : void 0;
+        if (field !== void 0 && !out.includes(field)) out.push(field);
+      }
+    }
+    for (const item of expr) ownerColumnsFromPolicy(item, out);
+  }
+  return out;
+}
+function policiesSelfIdentify(policies) {
+  if (policies === void 0) return false;
+  return [policies.read, policies.create, policies.update, policies.delete].some(
+    (expr) => expr !== void 0 && ownerColumnsFromPolicy(expr).includes("id")
+  );
+}
 function ownerFieldsFromSchema(schema) {
   const identities = identityEntityNames(schema);
   if (identities.length === 0) return [];
   const out = [];
-  const defs = inlineEntities(schema);
+  const defs = inlineEntities2(schema);
   const declaredByCollection = /* @__PURE__ */ new Map();
   for (const def of defs) {
     for (const field of def.fields ?? []) {
-      if (field.name && field.type === "relation" && identities.includes(field.relation.entity)) {
+      if (field.name && field.type === "relation" && !field.intrinsic && identities.includes(field.relation.entity)) {
         out.push(`${def.name}.${field.name}`);
         if (def.collection) {
           const cols = declaredByCollection.get(def.collection) ?? [];
@@ -225,6 +332,23 @@ function ownerFieldsFromSchema(schema) {
       }
     }
   }
+  for (const name of identities) {
+    if (policiesSelfIdentify(entityAccessPolicies(schema, name))) {
+      const key = `${name}.id`;
+      if (!out.includes(key)) out.push(key);
+    }
+  }
+  for (const def of defs) {
+    const policies = entityAccessPolicies(schema, def.name);
+    if (policies === void 0) continue;
+    for (const policy of [policies.read, policies.update, policies.delete]) {
+      if (policy === void 0) continue;
+      for (const field of ownerColumnsFromPolicy(policy)) {
+        const key = `${def.name}.${field}`;
+        if (!out.includes(key)) out.push(key);
+      }
+    }
+  }
   for (const def of defs) {
     const cols = def.collection ? declaredByCollection.get(def.collection) : void 0;
     if (!cols) continue;
@@ -236,64 +360,62 @@ function ownerFieldsFromSchema(schema) {
   }
   return out;
 }
-
-// src/access/entityAccess.ts
-function inlineEntities2(schema) {
-  const out = [];
-  for (const orbital of schema.orbitals ?? []) {
-    const refs = [orbital.entity, ...orbital.auxiliaryEntities ?? []];
-    for (const ref of refs) {
-      if (typeof ref === "object" && ref !== null && "fields" in ref) {
-        out.push(ref);
-      }
-    }
-  }
-  return out;
+var EQUALITY_OPS = ["=", "==", "!=", "!==", "eq", "neq"];
+function isUserFieldSigil(x) {
+  return typeof x === "string" && fieldRefName(x, "@user") !== void 0;
 }
-function isDeclared(p) {
-  return p.read !== void 0 || p.create !== void 0 || p.update !== void 0 || p.delete !== void 0;
+function literalHaystackMembers(items) {
+  const isListCall = items[0] === "list";
+  const members = isListCall ? items.slice(1) : items;
+  return members.every((v) => typeof v === "string") ? [...members] : void 0;
 }
-function entityAccessTable(schema) {
-  const table = /* @__PURE__ */ new Map();
-  const collectionOf = /* @__PURE__ */ new Map();
-  for (const def of inlineEntities2(schema)) {
-    table.set(def.name, {
-      read: def.read_policy,
-      create: def.create_policy,
-      update: def.update_policy,
-      delete: def.delete_policy
-    });
-    if (def.collection) collectionOf.set(def.name, def.collection);
-  }
-  const byCollection = /* @__PURE__ */ new Map();
-  for (const [name, policies] of table) {
-    const collection = collectionOf.get(name);
-    if (collection && isDeclared(policies) && !byCollection.has(collection)) {
-      byCollection.set(collection, policies);
+function collectUserFieldLiterals(expr, out = /* @__PURE__ */ new Map()) {
+  if (Array.isArray(expr)) {
+    const [op, ...args] = expr;
+    if (typeof op === "string" && args.length >= 2 && (EQUALITY_OPS.includes(op) || op === "array/includes")) {
+      const isIncludes = op === "array/includes";
+      let sigilSide;
+      let literalSide;
+      if (isIncludes) {
+        if (isUserFieldSigil(args[0])) {
+          sigilSide = args.slice(0, 1);
+          literalSide = args.slice(1, 2);
+        } else {
+          sigilSide = args.slice(1, 2);
+          literalSide = args.slice(0, 1);
+        }
+      } else {
+        sigilSide = args;
+        literalSide = args;
+      }
+      const field = sigilSide.map((arg) => fieldRefName(arg, "@user")).find((f) => f !== void 0);
+      if (field !== void 0) {
+        const literalArrayHaystack = literalSide[0];
+        const literals = isIncludes && Array.isArray(literalArrayHaystack) ? literalHaystackMembers(literalArrayHaystack) ?? [] : literalSide;
+        for (const literal of literals) {
+          if (typeof literal === "string" && !literal.startsWith("@")) {
+            const set = out.get(field) ?? /* @__PURE__ */ new Set();
+            set.add(literal);
+            out.set(field, set);
+          }
+        }
+      }
     }
+    for (const item of expr) collectUserFieldLiterals(item, out);
+    return out;
   }
-  for (const [name, policies] of table) {
-    if (isDeclared(policies)) continue;
-    const collection = collectionOf.get(name);
-    const inherited = collection ? byCollection.get(collection) : void 0;
-    if (inherited) table.set(name, { ...inherited });
+  if (expr !== null && typeof expr === "object") {
+    for (const value of Object.values(expr)) collectUserFieldLiterals(value, out);
   }
-  return table;
+  return out;
 }
-function entityAccessPolicies(schema, entityName) {
-  return entityAccessTable(schema).get(entityName);
-}
-function entityAccessPoliciesByStoreKey(schema) {
-  const collectionOf = /* @__PURE__ */ new Map();
-  for (const def of inlineEntities2(schema)) {
-    if (def.collection) collectionOf.set(def.name, def.collection);
-  }
-  const byKey = /* @__PURE__ */ new Map();
-  for (const [name, policies] of entityAccessTable(schema)) {
-    const key = collectionOf.get(name) ?? name.toLowerCase();
-    if (!byKey.has(key) && isDeclared(policies)) byKey.set(key, policies);
-  }
-  return byKey;
+function roleSatisfyingPolicy(policy, identity, field = "role") {
+  if (policy === void 0 || policy === null) return void 0;
+  const vocab = roleVocabularyOf(identity, field);
+  if (vocab === void 0) return void 0;
+  const accepted = collectUserFieldLiterals(policy).get(field);
+  if (accepted === void 0) return void 0;
+  return vocab.find((value) => accepted.has(value));
 }
 var ID_PREFIXES = {
   orbital: "orb_",
@@ -712,6 +834,9 @@ var EntityPersistenceSchema = z.enum([
 ]);
 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`,
@@ -870,6 +995,9 @@ function sampleUnion(field, ctx) {
   const child = { ...firstVariant, name: field.name };
   return sampleFieldValue(child, { ...ctx, depth: depth + 1 });
 }
+function omitsUndefaultedOptionalFields(ctx) {
+  return ctx.strategy === "seeded" && ctx.index % 2 === 0;
+}
 function sampleFieldValue(field, ctx) {
   const honoredDefault = field.default !== void 0 && isFieldValue(field.default) ? field.default : void 0;
   if (field.intrinsic === true) return honoredDefault;
@@ -878,6 +1006,9 @@ function sampleFieldValue(field, ctx) {
   if (!isRuntime && isDeclaredDefaultHonored(field) && honoredDefault !== void 0) {
     return honoredDefault;
   }
+  if (!field.required && field.default === void 0 && field.type !== "relation" && omitsUndefaultedOptionalFields(ctx)) {
+    return void 0;
+  }
   const values = declaredValues(field);
   if (values) {
     const ordinal = isRuntime ? 1 : ctx.index;
@@ -977,6 +1108,6 @@ function sampleRows(entity, count, strategy) {
   return rows;
 }
 
-export { IMAGE_FIELD_NAMES, entityAccessPolicies, entityAccessPoliciesByStoreKey, entityAccessTable, identityEntityName, isDeclaredDefaultHonored, ownerFieldsFromSchema, randomAnytimeDate, randomArrayElement, randomBoolean, randomColor, randomEmail, randomFloat, randomInt, randomPassword, randomPastDate, randomPhone, randomRecentDate, randomSentence, randomStraddlingDate, randomUrl, randomUuid, randomWords, sampleFieldValue, sampleImageUrl, sampleRow, sampleRowCount, sampleRows, seedRandom, shuffleArray };
+export { IMAGE_FIELD_NAMES, collectUserFieldLiterals, entityAccessPolicies, entityAccessPoliciesByStoreKey, entityAccessTable, identityEntitiesOf, identityEntityName, identityEntityNames, isDeclaredDefaultHonored, ownerColumnsFromPolicy, ownerFieldsFromSchema, randomAnytimeDate, randomArrayElement, randomBoolean, randomColor, randomEmail, randomFloat, randomInt, randomPassword, randomPastDate, randomPhone, randomRecentDate, randomSentence, randomStraddlingDate, randomUrl, randomUuid, randomWords, roleSatisfyingPolicy, roleVocabularyOf, sampleFieldValue, sampleImageUrl, sampleRow, sampleRowCount, sampleRows, seedRandom, shuffleArray };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map