@almadar/core 10.129.0 → 11.0.1

package/dist/chunk-GF7KCLNR.js

@@ -0,0 +1,3284 @@
+import { OrbitalSchemaSchema, SourceDeclarationMetadataSchema } from './chunk-PNGFWLHD.js';
+import { FieldValueSchema, EntityRowSchema, SERVER_REPORTED_EFFECTS } from './chunk-FGT5OS2Y.js';
+import { EventPayloadValueSchema, EventPayloadSchema } from './chunk-347APWFM.js';
+import { JsonValueSchema, isJsonObject } from './chunk-7GHJU5WI.js';
+import { z } from 'zod';
+
+// src/types/observability.ts
+var CALL_KINDS = ["client", "server", "db", "queue", "external"];
+var LOG_SEVERITIES = ["DEBUG", "INFO", "WARNING", "ERROR"];
+function isCallKind(value) {
+  return typeof value === "string" && CALL_KINDS.some((k) => k === value);
+}
+function isSeverity(value) {
+  return typeof value === "string" && LOG_SEVERITIES.some((s) => s === value);
+}
+function optionalString(value) {
+  return value === void 0 || typeof value === "string";
+}
+function isCallRecord(value) {
+  if (value === void 0 || !isJsonObject(value)) return false;
+  const { kind, service, op, durationMs, ok, error } = value;
+  if (!isCallKind(kind) || typeof service !== "string" || typeof op !== "string") return false;
+  if (typeof durationMs !== "number" || !Number.isFinite(durationMs) || durationMs < 0) return false;
+  if (typeof ok !== "boolean" || !optionalString(error)) return false;
+  return !(ok && error !== void 0);
+}
+function isStructuredLogEntry(value) {
+  if (!isJsonObject(value)) return false;
+  const { severity, time, namespace, message, data, call, appId, deploymentCommit } = value;
+  if (!isSeverity(severity) || typeof time !== "string" || typeof namespace !== "string" || typeof message !== "string") return false;
+  if (data !== void 0 && !isJsonObject(data)) return false;
+  if (call !== void 0 && !isCallRecord(call)) return false;
+  return optionalString(appId) && optionalString(deploymentCommit);
+}
+var BindingSchema = z.string().refine(
+  (val) => {
+    if (!val.startsWith("@")) return false;
+    const parts = val.slice(1).split(".");
+    if (parts.length === 0 || parts[0] === "") return false;
+    return parts.every((part) => /^[\p{L}_][\p{L}0-9_]*$/u.test(part));
+  },
+  { message: "Invalid binding format. Must be @name or @name.path.to.field" }
+);
+var BINDING_DOCS = {
+  entity: {
+    description: "Reference to the linked entity for this trait",
+    examples: ["@entity.health", "@entity.x", "@entity.status"],
+    requiresPath: true
+  },
+  payload: {
+    description: "Reference to the event payload data",
+    examples: ["@payload.amount", "@payload.targetId", "@payload.action"],
+    requiresPath: true
+  },
+  state: {
+    description: "Current state machine state name",
+    examples: ["@state"],
+    requiresPath: false
+  },
+  now: {
+    description: "Current timestamp in milliseconds",
+    examples: ["@now"],
+    requiresPath: false
+  },
+  config: {
+    description: "Trait configuration values",
+    examples: ["@config.apiEndpoint", "@config.theme"],
+    requiresPath: true
+  },
+  computed: {
+    description: "Computed/calculated values",
+    examples: ["@computed.total", "@computed.isValid"],
+    requiresPath: true
+  },
+  trait: {
+    description: "Trait context data",
+    examples: ["@trait.name", "@trait.category"],
+    requiresPath: true
+  },
+  user: {
+    description: "Authenticated user / agent context for ownership and role-based gating",
+    examples: ["@user.id", "@user.role"],
+    requiresPath: true
+  },
+  callsitePayload: {
+    description: "Call-site-captured event payload \u2014 emitted by the compiler's inline-trait hoisting when an extracted render block captured @payload; resolved at the composing effect by the runtime BindingResolver",
+    examples: ["@callsitePayload.error", "@callsitePayload.row"],
+    requiresPath: true
+  },
+  pages: {
+    description: "Render-resolved schema sigil \u2014 the host orbital's pages as a NavItem[] array (href = page.path, label = page.name). Substituted from the OrbitalSchema before codegen; never survives as a live binding.",
+    examples: ["@pages"],
+    requiresPath: false
+  },
+  currentTheme: {
+    description: "Render-resolved schema sigil \u2014 the host orbital's active data-theme key, derived from Orbital.theme. Substituted from the OrbitalSchema before codegen; never survives as a live binding.",
+    examples: ["@currentTheme"],
+    requiresPath: false
+  },
+  locale: {
+    description: "The active locale code (`en`, `ar`, `sl`, \u2026) \u2014 the locale whose catalog `i18n/t` reads, set by the host from the route.",
+    examples: ["@locale"],
+    requiresPath: false
+  },
+  event: {
+    description: "The delivery being processed: { event, payload, source } \u2014 for a listens delivery the source emit, with its BusEventSource envelope (Runtime Spec Clause 5.5)",
+    examples: ["@event.event", "@event.payload.n", "@event.source.trait", "@event.source.tick"],
+    requiresPath: false
+  },
+  prevEvents: {
+    description: "The deliveries this trait already received in this dispatch, in order, each shaped like @event",
+    examples: ["@prevEvents"],
+    requiresPath: false
+  },
+  prevStates: {
+    description: "The states this trait left in this dispatch, in order",
+    examples: ["@prevStates"],
+    requiresPath: false
+  },
+  fromState: {
+    description: "The transition's source state",
+    examples: ["@fromState"],
+    requiresPath: false
+  },
+  toState: {
+    description: "The transition's target state (null in a listens `when`, where no transition is chosen yet)",
+    examples: ["@toState"],
+    requiresPath: false
+  }
+};
+var BINDING_CONTEXT_RULES = {
+  guard: {
+    allowed: ["entity", "payload", "state", "now", "config", "user", "event", "prevEvents", "prevStates", "fromState", "toState"],
+    description: `Guards can read the delivery being processed and this dispatch's log (@event, @prevEvents, @prevStates) and the transition's ends (@fromState, @toState; Runtime Spec Clause 5.5). Guards can access entity fields, event payload, current state, time, the call-site trait config (@config.X), and the authenticated user context (@user.id, @user.role) for ownership / role gates. Config access lets atoms write mode-aware guards \u2014 e.g. std-modal's OPEN can require @payload.row only when @config.mode equals "edit", letting create-mode legitimately fire OPEN with no row. Like effects, @config.X is substituted at molecule/organism inline time with the literal call-site value; at atom-scope validate, @config is allowed-but-unresolved.`
+  },
+  effect: {
+    allowed: ["entity", "payload", "state", "now", "trait", "config", "user", "callsitePayload", "pages", "currentTheme", "locale", "event", "prevEvents", "prevStates", "fromState", "toState"],
+    description: "Effects can access and modify entity fields, use payload data, embed another trait's live frame via @trait.X inside render-ui children, read trait config values (@config.X) for atoms parameterized by their call-site, and read the authenticated user context (@user.id, @user.role). At molecule/organism inline time, @config.X is substituted with the literal value from the call-site config block; at atom-scope validate, @config is allowed-but-unresolved. @callsitePayload.X is the call-site-captured event payload emitted by the compiler's inline-trait hoisting (a hoisted render block that captured @payload); it is resolved at the composing effect by the runtime BindingResolver."
+  },
+  tick: {
+    allowed: ["entity", "state", "now", "config", "user"],
+    description: "Ticks can access entity fields, current state, time, trait config (@config.X) for parameterized atoms, and the authenticated user context (@user.id, @user.role). Same substitution semantics as guards/effects."
+  }
+};
+var RENDER_BINDING_MARKER = "$renderBinding";
+function isRenderBindingMarker(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && RENDER_BINDING_MARKER in value && value[RENDER_BINDING_MARKER] === true;
+}
+var ENTITY_BINDING_RE = /@entity(?=[.\[\]]|$)/;
+var PAYLOAD_BINDING_RE = /@(?:callsitePayload|payload)(?=[.\[\]]|$)/;
+function containsEntityBinding(value) {
+  if (typeof value === "string") return ENTITY_BINDING_RE.test(value);
+  if (Array.isArray(value)) return value.some(containsEntityBinding);
+  if (value !== null && typeof value === "object") {
+    if (isRenderBindingMarker(value)) return true;
+    return Object.values(value).some(containsEntityBinding);
+  }
+  return false;
+}
+function containsPayloadBinding(value) {
+  if (typeof value === "string") return PAYLOAD_BINDING_RE.test(value);
+  if (Array.isArray(value)) return value.some(containsPayloadBinding);
+  if (value !== null && typeof value === "object") {
+    return Object.values(value).some(containsPayloadBinding);
+  }
+  return false;
+}
+function validateBindingInContext(binding, context) {
+  const rules = BINDING_CONTEXT_RULES[context];
+  if (binding.type === "core") {
+    if (!rules.allowed.includes(binding.root)) {
+      return `Binding @${binding.root} is not allowed in ${context} context. Allowed: ${rules.allowed.join(", ")}`;
+    }
+  }
+  return null;
+}
+function getBindingExamples(context) {
+  const rules = BINDING_CONTEXT_RULES[context];
+  const examples = [];
+  for (const binding of rules.allowed) {
+    const doc = BINDING_DOCS[binding];
+    examples.push(...doc.examples);
+  }
+  examples.push("@GameConfig.gravity", "@Filter.searchTerm");
+  return examples;
+}
+var CompareOpSchema = z.enum(["==", "!=", "<", "<=", ">", ">="]);
+var RowPredicateSchema = z.lazy(
+  () => z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("compare"), field: z.string(), op: CompareOpSchema, value: FieldValueSchema }),
+    z.object({ kind: z.literal("member"), field: z.string(), values: z.array(FieldValueSchema) }),
+    z.object({ kind: z.literal("hasElement"), field: z.string(), value: FieldValueSchema }),
+    z.object({ kind: z.literal("contains"), field: z.string(), text: z.string(), caseSensitive: z.boolean() }),
+    z.object({ kind: z.literal("isNull"), field: z.string(), isNull: z.boolean() }),
+    z.object({ kind: z.literal("all"), of: z.array(RowPredicateSchema) }),
+    z.object({ kind: z.literal("any"), of: z.array(RowPredicateSchema) }),
+    z.object({ kind: z.literal("not"), of: RowPredicateSchema }),
+    z.object({ kind: z.literal("const"), value: z.boolean() })
+  ])
+);
+var RowQuerySchema = z.object({
+  policy: RowPredicateSchema.optional(),
+  filter: RowPredicateSchema.optional(),
+  order: z.object({ field: z.string(), direction: z.enum(["asc", "desc"]) }).optional(),
+  offset: z.number().int().nonnegative().optional(),
+  limit: z.number().int().nonnegative().optional(),
+  total: z.enum(["exact", "none"]).optional(),
+  nearest: z.object({ field: z.string(), vector: z.array(z.number()), k: z.number().int().positive() }).optional()
+});
+var RowIdPageSchema = z.object({
+  ids: z.array(z.string()),
+  total: z.number().int().nonnegative()
+});
+var RowWriteOpSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("create"), entityType: z.string(), data: EntityRowSchema }),
+  z.object({ kind: z.literal("upsert"), entityType: z.string(), data: EntityRowSchema }),
+  z.object({ kind: z.literal("update"), entityType: z.string(), id: z.string(), data: EntityRowSchema, guard: RowPredicateSchema.optional() }),
+  z.object({ kind: z.literal("delete"), entityType: z.string(), id: z.string(), guard: RowPredicateSchema.optional() }),
+  z.object({ kind: z.literal("rekey"), entityType: z.string(), id: z.string(), newId: z.string().min(1), guard: RowPredicateSchema.optional() })
+]);
+var RowWriteOutcomeSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("created"), row: EntityRowSchema }),
+  z.object({ kind: z.literal("updated"), row: EntityRowSchema, before: EntityRowSchema.optional() }),
+  z.object({ kind: z.literal("deleted"), before: EntityRowSchema.optional() }),
+  z.object({ kind: z.literal("not-found") }),
+  z.object({ kind: z.literal("duplicate-id") }),
+  z.object({ kind: z.literal("refused") }),
+  z.object({ kind: z.literal("failed"), message: z.string() }),
+  z.object({ kind: z.literal("rolled-back") })
+]);
+var RowWriteBatchSchema = z.object({
+  ops: z.array(RowWriteOpSchema),
+  onFailure: z.enum(["atomic", "stop"])
+});
+var LeafKindSchema = z.enum(["compare", "member", "hasElement", "contains", "isNull"]);
+var CombinatorSchema = z.enum(["all", "any", "not"]);
+var RowOperatorSchema = z.enum(["==", "!=", "<", "<=", ">", ">=", "member", "hasElement", "contains"]);
+var RowValueKindSchema = z.enum(["string", "number", "boolean", "date", "null"]);
+var RowCommitSchema = z.object({
+  entityType: z.string(),
+  id: z.string(),
+  expected: EntityRowSchema.nullable(),
+  write: z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("keep") }),
+    z.object({ kind: z.literal("put"), row: EntityRowSchema }),
+    z.object({ kind: z.literal("delete") })
+  ])
+});
+var QueryCapabilitiesSchema = z.object({
+  leaves: z.array(LeafKindSchema),
+  combinators: z.array(CombinatorSchema),
+  compareOps: z.array(CompareOpSchema),
+  operatorValueKinds: z.array(z.object({ operator: RowOperatorSchema, valueKinds: z.array(RowValueKindSchema) })).optional(),
+  orderableFields: z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("every-field") }),
+    z.object({ kind: z.literal("listed"), fields: z.array(z.string()) })
+  ]),
+  window: z.boolean(),
+  exactTotal: z.boolean(),
+  idsOnly: z.boolean().optional(),
+  nearest: z.boolean().optional()
+});
+var WriteCapabilitiesSchema = z.object({
+  guards: z.object({ leaves: z.array(LeafKindSchema), combinators: z.array(CombinatorSchema), compareOps: z.array(CompareOpSchema) }),
+  conditional: z.boolean(),
+  returnsRow: z.boolean(),
+  stopRuns: z.boolean(),
+  atomicBatch: z.boolean(),
+  rekey: z.boolean().optional(),
+  commitRows: z.boolean().optional()
+});
+var RowQueryPageSchema = z.object({
+  rows: z.array(EntityRowSchema),
+  total: z.number().int().nonnegative()
+});
+function isMissing(value) {
+  return value === null || value === void 0;
+}
+function comparable(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function codePointOrder(a, b) {
+  const x = Array.from(a);
+  const y = Array.from(b);
+  const n = Math.min(x.length, y.length);
+  for (let i = 0; i < n; i++) {
+    const cx = x[i].codePointAt(0) ?? 0;
+    const cy = y[i].codePointAt(0) ?? 0;
+    if (cx !== cy) return cx < cy ? -1 : 1;
+  }
+  return x.length === y.length ? 0 : x.length < y.length ? -1 : 1;
+}
+function orderValues(a, b) {
+  if (typeof a === "string" && typeof b === "string") return codePointOrder(a, b);
+  if (typeof a === "number" && typeof b === "number") return a === b ? 0 : a < b ? -1 : 1;
+  if (typeof a === "boolean" && typeof b === "boolean") return a === b ? 0 : a ? 1 : -1;
+  return null;
+}
+function sameValue(a, b) {
+  return a === b;
+}
+function compareLeaf(value, op) {
+  const target = op.value;
+  if (isMissing(value)) return op.op === "!=" && !isMissing(target);
+  switch (op.op) {
+    case "==":
+      return sameValue(value, target);
+    case "!=":
+      return !sameValue(value, target);
+    default: {
+      if (!comparable(value) || !comparable(target)) return false;
+      const c = orderValues(value, target);
+      if (c === null) return false;
+      if (op.op === "<") return c < 0;
+      if (op.op === "<=") return c <= 0;
+      if (op.op === ">") return c > 0;
+      return c >= 0;
+    }
+  }
+}
+function foldCase(text) {
+  return text.toUpperCase().toLowerCase();
+}
+var memberLookups = /* @__PURE__ */ new WeakMap();
+function memberLookup(predicate) {
+  const cached = memberLookups.get(predicate);
+  if (cached !== void 0) return cached;
+  const lookup = new Set(predicate.values);
+  memberLookups.set(predicate, lookup);
+  return lookup;
+}
+function rowMatchesPredicate(row, predicate) {
+  switch (predicate.kind) {
+    case "const":
+      return predicate.value;
+    case "all":
+      return predicate.of.every((p) => rowMatchesPredicate(row, p));
+    case "any":
+      return predicate.of.some((p) => rowMatchesPredicate(row, p));
+    case "not":
+      return !rowMatchesPredicate(row, predicate.of);
+    case "compare":
+      return compareLeaf(row[predicate.field], predicate);
+    case "isNull":
+      return isMissing(row[predicate.field]) === predicate.isNull;
+    case "member": {
+      const value = row[predicate.field];
+      if (isMissing(value)) return false;
+      const lookup = memberLookup(predicate);
+      return !Number.isNaN(value) && lookup.has(value);
+    }
+    case "hasElement": {
+      const value = row[predicate.field];
+      return Array.isArray(value) && value.some((v) => sameValue(v, predicate.value));
+    }
+    case "contains": {
+      const value = row[predicate.field];
+      if (typeof value !== "string") return false;
+      return predicate.caseSensitive ? value.includes(predicate.text) : foldCase(value).includes(foldCase(predicate.text));
+    }
+  }
+}
+function rowIdOf(row) {
+  return typeof row.id === "string" ? row.id : null;
+}
+function runRowWrite(rows, op) {
+  if (op.kind === "rekey") return { rows: [...rows], outcome: { kind: "failed", message: "rekey is unsupported by this store" } };
+  if (op.kind === "create") {
+    const id = rowIdOf(op.data);
+    if (id === null) return { rows: [...rows], outcome: { kind: "failed", message: "create needs a string id" } };
+    if (rows.some((r) => r.id === id)) return { rows: [...rows], outcome: { kind: "duplicate-id" } };
+    const row2 = { ...op.data };
+    return { rows: [...rows, row2], outcome: { kind: "created", row: row2 } };
+  }
+  if (op.kind === "upsert") {
+    const id = rowIdOf(op.data);
+    if (id === null) return { rows: [...rows], outcome: { kind: "failed", message: "upsert needs a string id" } };
+    const index2 = rows.findIndex((r) => r.id === id);
+    if (index2 < 0) {
+      const row3 = { ...op.data };
+      return { rows: [...rows, row3], outcome: { kind: "created", row: row3 } };
+    }
+    const kept = rows[index2].createdAt;
+    const row2 = kept === void 0 ? { ...op.data } : { ...op.data, createdAt: kept };
+    return { rows: rows.map((r, i) => i === index2 ? row2 : r), outcome: { kind: "updated", row: row2 } };
+  }
+  const index = rows.findIndex((r) => r.id === op.id);
+  if (index < 0) return { rows: [...rows], outcome: { kind: "not-found" } };
+  const before = rows[index];
+  if (op.guard !== void 0 && !rowMatchesPredicate(before, op.guard)) return { rows: [...rows], outcome: { kind: "refused" } };
+  const guarded = op.guard !== void 0 ? { before } : {};
+  if (op.kind === "delete") {
+    return { rows: rows.filter((_, i) => i !== index), outcome: { kind: "deleted", ...guarded } };
+  }
+  const row = { ...before, ...op.data, id: op.id };
+  return { rows: rows.map((r, i) => i === index ? row : r), outcome: { kind: "updated", row, ...guarded } };
+}
+var FULL_QUERY_CAPABILITIES = {
+  leaves: ["compare", "member", "hasElement", "contains", "isNull"],
+  combinators: ["all", "any", "not"],
+  compareOps: ["==", "!=", "<", "<=", ">", ">="]};
+var FULL_WRITE_CAPABILITIES = {
+  guards: { leaves: FULL_QUERY_CAPABILITIES.leaves, combinators: FULL_QUERY_CAPABILITIES.combinators, compareOps: FULL_QUERY_CAPABILITIES.compareOps },
+  conditional: true,
+  returnsRow: true,
+  stopRuns: true,
+  atomicBatch: true
+};
+var QueryDeclinedError = class extends Error {
+  constructor(reason, message) {
+    super(message ?? `query declined: ${reason}`);
+    this.name = "QueryDeclinedError";
+    this.reason = reason;
+  }
+};
+var WriteDeclinedError = class extends Error {
+  constructor(reason, message) {
+    super(message ?? `write declined: ${reason}`);
+    this.name = "WriteDeclinedError";
+    this.reason = reason;
+  }
+};
+
+// src/types/row-set.ts
+var RowSetRefSchema = z.object({
+  entityType: z.string(),
+  ids: z.array(z.string()),
+  total: z.number().int().nonnegative(),
+  query: RowQuerySchema
+});
+var ROW_SET_MARKER = "$rowSet";
+function rowSetMarker(ref) {
+  return { [ROW_SET_MARKER]: true, ref };
+}
+function isRowSetMarker(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && ROW_SET_MARKER in value && value[ROW_SET_MARKER] === true && "ref" in value && RowSetRefSchema.safeParse(value.ref).success;
+}
+var BINDING_ROOTS = [
+  "entity",
+  "payload",
+  "state",
+  "now",
+  "config",
+  "trait",
+  "user",
+  "callsitePayload",
+  "pages",
+  "currentTheme",
+  "locale",
+  "event",
+  "prevEvents",
+  "prevStates",
+  "fromState",
+  "toState",
+  "fromEntity",
+  "other"
+];
+var KNOWN_ROOTS = new Set(BINDING_ROOTS.filter((r) => r !== "other"));
+function toBindingRoot(root) {
+  return KNOWN_ROOTS.has(root) ? root : "other";
+}
+var TRAIT_REF_PATTERN = /^@trait\.[A-Z][a-zA-Z0-9]*$/;
+function isTraitFieldRef(value) {
+  return typeof value === "string" && TRAIT_REF_PATTERN.test(value);
+}
+var TraitFieldRefSchema = z.string().regex(TRAIT_REF_PATTERN, "expected `@trait.<TraitName>` reference");
+var ClaimSchema = z.object({ name: z.string(), value: JsonValueSchema });
+var ViewerSchema = z.object({
+  id: z.string(),
+  email: z.string().nullish(),
+  name: z.string().nullish(),
+  role: z.string().optional(),
+  permissions: z.array(z.string()).optional(),
+  claims: z.array(ClaimSchema)
+});
+var ANONYMOUS_USER = {
+  id: "anonymous",
+  role: "anonymous",
+  permissions: []
+};
+var RawUserClaimsSchema = z.object({
+  id: z.string().optional(),
+  uid: z.string().optional(),
+  email: z.string().nullable().optional(),
+  name: z.string().nullable().optional(),
+  displayName: z.string().nullable().optional(),
+  role: z.string().nullable().optional(),
+  permissions: z.array(z.string()).nullable().optional()
+}).catchall(FieldValueSchema);
+var NONE_WHEN_NULL_CLAIM_KEYS = ["role", "permissions"];
+var DERIVED_CLAIM_KEYS = ["id", "name", "displayName", "email"];
+function normalizeUserContext(claims) {
+  if (!claims) return void 0;
+  const id = claims.id ?? claims.uid;
+  if (typeof id !== "string" || id.length === 0) return void 0;
+  const user = { id };
+  for (const [key, value] of Object.entries(claims)) {
+    if (value === void 0 || DERIVED_CLAIM_KEYS.includes(key)) continue;
+    if (value === null && NONE_WHEN_NULL_CLAIM_KEYS.includes(key)) continue;
+    user[key] = value;
+  }
+  const name = claims.name ?? claims.displayName;
+  if (typeof name === "string" && name.length > 0) user.name = name;
+  if (typeof claims.email === "string" && claims.email.length > 0) user.email = claims.email;
+  return user;
+}
+function personaFromIdentityRow(row) {
+  const id = row["id"];
+  if (typeof id !== "string" || id.length === 0) return void 0;
+  const persona = { id };
+  for (const [key, value] of Object.entries(row)) {
+    if (key === "id" || value === void 0) continue;
+    persona[key] = value;
+  }
+  return persona;
+}
+function findPersonaInRoster(roster, idOrRole) {
+  return roster.find((p) => p.id === idOrRole) ?? roster.find((p) => p.role === idOrRole);
+}
+function resolvePersonaSpec(spec, roster) {
+  const raw = spec.trim();
+  if (!raw.startsWith("{")) {
+    const declared = findPersonaInRoster(roster, raw);
+    if (!declared) {
+      const known = roster.map((p) => `${p.id}/${p.role ?? "-"}`).join(", ");
+      throw new Error(
+        `Persona "${raw}" is not a declared persona id or role. ` + (roster.length > 0 ? `Known: ${known}` : "This app declares no [identity] entity, so only the JSON persona form is accepted.")
+      );
+    }
+    return declared;
+  }
+  let claims;
+  try {
+    claims = JSON.parse(raw);
+  } catch {
+    throw new Error(`Persona is not valid JSON: ${raw}`);
+  }
+  const user = normalizeUserContext(claims);
+  if (!user) {
+    throw new Error(`Persona needs an "id" (or "uid"): ${raw}`);
+  }
+  return user;
+}
+
+// src/types/agent.ts
+function isSessionHistoryEntry(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return "role" in value && typeof value.role === "string" && "content" in value && typeof value.content === "string" && "timestamp" in value && typeof value.timestamp === "number";
+}
+
+// src/types/plan.ts
+function isPlanSnapshot(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const statuses = ["proposed", "confirmed", "built", "failed"];
+  return "schemaVersion" in value && value.schemaVersion === 1 && "status" in value && statuses.some((s) => s === value.status) && "builtAt" in value && typeof value.builtAt === "string" && "orbitals" in value && Array.isArray(value.orbitals) && "renames" in value && Array.isArray(value.renames) && "deletedOrbitals" in value && Array.isArray(value.deletedOrbitals);
+}
+var PatternTypeSchema = z.string();
+
+// src/types/changeset.ts
+var SEMANTIC_CHANGE_KINDS = [
+  "orbital-added",
+  "orbital-removed",
+  "entity-fields-changed",
+  "trait-added",
+  "trait-removed",
+  "trait-config-changed",
+  "state-machine-changed",
+  "guard-changed",
+  "effect-changed",
+  "render-ui-changed",
+  "event-wiring-changed",
+  "page-changed",
+  "theme-changed",
+  "behavior-composed"
+];
+
+// src/service-types.ts
+function createTypedEventBus(bus) {
+  return {
+    emit(event, payload) {
+      bus.emit(event, payload);
+    },
+    on(event, handler) {
+      return bus.on(event, handler);
+    }
+  };
+}
+function createLazyService(factory) {
+  let instance = null;
+  return {
+    get() {
+      if (instance === null) {
+        instance = factory();
+      }
+      return instance;
+    },
+    reset() {
+      instance = null;
+    }
+  };
+}
+
+// src/row-predicate.ts
+function parseFetchOrder(orderBy) {
+  if (typeof orderBy !== "string" || orderBy === "") return void 0;
+  const [field, direction] = orderBy.split(":");
+  const dir = direction === "desc" ? "desc" : "asc";
+  return { field, direction: dir };
+}
+
+// src/types/visit-key.ts
+function isPayloadList(value) {
+  return Array.isArray(value);
+}
+function canonicalJson(value) {
+  if (value === void 0 || value === null) return "null";
+  if (isPayloadList(value)) return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
+  if (typeof value === "object") {
+    const fields = Object.keys(value).sort().map((k) => `${JSON.stringify(k)}:${canonicalJson(value[k])}`);
+    return `{${fields.join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function dispatchVisitKey(trait, event, from, payload, frame) {
+  return `${trait}\0${event}\0${from}\0${canonicalJson(payload)}\0${canonicalJson(frame)}`;
+}
+var COMPOSITE = /* @__PURE__ */ Symbol("composite");
+function canonicalLeaf(value) {
+  if (value === void 0 || value === null) return null;
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "object") return COMPOSITE;
+  return value;
+}
+function sameCanonical(a, b) {
+  if (a === b) return true;
+  const leafA = canonicalLeaf(a);
+  const leafB = canonicalLeaf(b);
+  if (leafA !== COMPOSITE || leafB !== COMPOSITE) return leafA === leafB;
+  if (isPayloadList(a) || isPayloadList(b)) {
+    if (!isPayloadList(a) || !isPayloadList(b) || a.length !== b.length) return false;
+    return a.every((item, i) => sameCanonical(item, b[i]));
+  }
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  return keysA.length === keysB.length && keysA.every((k) => k in b && sameCanonical(a[k], b[k]));
+}
+var DispatchVisits = class {
+  constructor() {
+    this.steps = /* @__PURE__ */ new Map();
+  }
+  has(trait, event, from, payload, frame) {
+    const seen = this.steps.get(`${trait}\0${event}\0${from}`);
+    return seen !== void 0 && seen.some((v) => sameCanonical(v.payload, payload) && sameCanonical(v.frame, frame));
+  }
+  add(trait, event, from, payload, frame) {
+    if (this.has(trait, event, from, payload, frame)) return;
+    const step = `${trait}\0${event}\0${from}`;
+    const visit = {
+      payload: payload === void 0 || payload === null ? null : { ...payload },
+      frame: frame === null ? null : { ...frame }
+    };
+    const seen = this.steps.get(step);
+    if (seen === void 0) this.steps.set(step, [visit]);
+    else seen.push(visit);
+  }
+};
+
+// src/types/guard-holds.ts
+function guardHolds(check, onError) {
+  try {
+    return check();
+  } catch (error) {
+    onError(error instanceof Error ? error : new Error(String(error)));
+    return false;
+  }
+}
+var ServerBatchSummarySchema = z.object({
+  operations: z.array(EntityRowSchema),
+  completedCount: z.number(),
+  totalCount: z.number()
+});
+var ServerEffectResultSchema = z.object({
+  effect: z.union([z.enum(SERVER_REPORTED_EFFECTS), z.literal("substrate")]),
+  action: z.string().optional(),
+  entityType: z.string().optional(),
+  name: z.custom((v) => typeof v === "string" && /^[^/]+\/.+$/.test(v)).optional(),
+  data: z.union([EntityRowSchema, ServerBatchSummarySchema, EventPayloadValueSchema]).optional(),
+  success: z.boolean(),
+  denied: z.literal(true).optional(),
+  error: z.string().optional(),
+  code: z.enum(["not-found", "no-row-key", "duplicate-id", "denied", "derived-failed"]).optional(),
+  target: z.string().optional(),
+  routed: z.string().optional()
+});
+
+// src/types/verification-ids.json
+var verification_ids_default = {
+  actionPrefix: "action-",
+  overflowKey: "overflow",
+  gestureEventProps: {
+    longPressEvent: "long-press",
+    swipeLeftEvent: "swipe-left",
+    swipeRightEvent: "swipe-right"
+  },
+  nativeIdPrefix: {
+    pattern: "pattern-",
+    row: "row-",
+    field: "field-",
+    slot: "slot-"
+  },
+  nativeIdSeparator: " "
+};
+
+// src/types/verification.ts
+var PATTERN_PROP_TYPE_ERROR_TESTID = "pattern-prop-type-error";
+var TRAIT_MOUNT_ERROR_TESTID = "trait-mount-error";
+var EMPTY_STATE_MARKER = "data-empty-state";
+var LOADING_STATE_MARKER = "data-loading-state";
+var VERIFICATION_DOM_ATTRS = {
+  pattern: "data-pattern",
+  rowId: "data-row-id",
+  entityRow: "data-entity-row",
+  entityId: "data-entity-id",
+  fieldName: "data-field-name",
+  event: "data-event"
+};
+var ACTION_TESTID_PREFIX = verification_ids_default.actionPrefix;
+var ACTION_OVERFLOW_TESTID = `${ACTION_TESTID_PREFIX}${verification_ids_default.overflowKey}`;
+var FORM_PATTERN = "form-section";
+function actionTestId(eventKey) {
+  return `${ACTION_TESTID_PREFIX}${eventKey}`;
+}
+function actionTestIdMatches(testId, event) {
+  if (!testId.startsWith(ACTION_TESTID_PREFIX)) return false;
+  const key = testId.slice(ACTION_TESTID_PREFIX.length);
+  return key === event || key.endsWith(`.${event}`);
+}
+var GESTURES = ["tap", "long-press", "swipe-left", "swipe-right"];
+function gestureOf(name) {
+  const gesture = GESTURES.find((g) => g !== "tap" && g === name);
+  if (gesture === void 0) throw new Error(`verification-ids.json names an unknown gesture "${name}"`);
+  return gesture;
+}
+var GESTURE_EVENT_PROPS = Object.fromEntries(
+  Object.entries(verification_ids_default.gestureEventProps).map(([prop, gesture]) => [prop, gestureOf(gesture)])
+);
+function gestureActionTestId(eventKey, gesture) {
+  return gesture === "tap" ? actionTestId(eventKey) : `${ACTION_TESTID_PREFIX}${gesture}:${eventKey}`;
+}
+function gestureOfActionTestId(testId, event) {
+  if (!testId.startsWith(ACTION_TESTID_PREFIX)) return null;
+  const rest = testId.slice(ACTION_TESTID_PREFIX.length);
+  const colon = rest.indexOf(":");
+  const gesture = colon < 0 ? "tap" : GESTURES.find((g) => g !== "tap" && g === rest.slice(0, colon));
+  if (gesture === void 0) return null;
+  const key = colon < 0 ? rest : rest.slice(colon + 1);
+  return key === event || key.endsWith(`.${event}`) ? gesture : null;
+}
+var NATIVE_ID_PREFIX = verification_ids_default.nativeIdPrefix;
+var NATIVE_ID_SEPARATOR = verification_ids_default.nativeIdSeparator;
+function nativeIds(...ids) {
+  return ids.filter((id) => id !== "").join(NATIVE_ID_SEPARATOR);
+}
+function splitNativeIds(identifier) {
+  return identifier.split(NATIVE_ID_SEPARATOR).filter((id) => id !== "");
+}
+function nativePatternId(name) {
+  return `${NATIVE_ID_PREFIX.pattern}${name}`;
+}
+function nativeRowId(id) {
+  return `${NATIVE_ID_PREFIX.row}${id}`;
+}
+function nativeFieldId(name) {
+  return `${NATIVE_ID_PREFIX.field}${name}`;
+}
+function nativeSlotId(name) {
+  return `${NATIVE_ID_PREFIX.slot}${name}`;
+}
+
+// src/generated/language/validation-codes.json
+var validation_codes_default = [
+  {
+    code: "ORB_T_MISSING_RENDER_UI",
+    category: "trait",
+    description: "Interaction trait missing render_ui effects"
+  },
+  {
+    code: "ORB_T_BEHAVIOR_REF_UNRESOLVED",
+    category: "trait",
+    description: "A trait-value literal (`<spec>.traits.<Trait>`) whose behavior or trait does not resolve against the installed behavior packages."
+  },
+  {
+    code: "ORB_T_BEHAVIOR_REF_NOT_LITERAL",
+    category: "trait",
+    description: "A `behavior/ref` whose argument is computed at run time: a behavior from data must arrive as a `behavior` value, never re-parsed from text."
+  },
+  {
+    code: "ORB_T_UNQUOTE_OUTSIDE_QUASIQUOTE",
+    category: "trait",
+    description: 'An `["unquote", \u2026]` call outside a quasiquote body in an `.orb` input.'
+  },
+  {
+    code: "ORB_T_EVENT_REF_UNRESOLVED",
+    category: "trait",
+    description: "An event-typed config value addresses a trait the program does not have."
+  },
+  {
+    code: "ORB_T_EVENT_REF_NOT_EXTERNAL_INPUT",
+    category: "trait",
+    description: "An event-typed config value addresses an event its trait does not declare as an external input."
+  },
+  {
+    code: "ORB_T_CONFIG_SHAPE_MISMATCH",
+    category: "trait",
+    description: "Config field's default value doesn't match its declared structural shape (array vs scalar, object vs string, missing required, etc.). Fires after the typed-config carriers (`items` / `properties` / `values`) make the declared shape concrete enough to check against."
+  },
+  {
+    code: "ORB_T_TYPE_UNKNOWN",
+    category: "trait",
+    description: "A type reference names no declared type, entity or primitive"
+  },
+  {
+    code: "ORB_T_TYPE_CYCLE",
+    category: "trait",
+    description: "A type composition chain refers back to itself"
+  },
+  {
+    code: "ORB_T_TYPE_KIND_MISMATCH",
+    category: "trait",
+    description: "Composed types do not share a kind (all Entity, all Trait, \u2026)"
+  },
+  {
+    code: "ORB_T_TYPE_COMPOSITION_CONFLICT",
+    category: "trait",
+    description: "A field is declared in more than one composed entity"
+  },
+  {
+    code: "ORB_T_TYPE_ANNOTATION_MISMATCH",
+    category: "trait",
+    description: "A type body does not match its `::` type annotation"
+  },
+  {
+    code: "ORB_T_TYPE_UNKNOWN_PARAM",
+    category: "trait",
+    description: "A type alias body uses a type parameter the alias does not declare"
+  },
+  {
+    code: "ORB_T_TYPE_WRONG_ARG_COUNT",
+    category: "trait",
+    description: "A type alias is applied with the wrong number of type arguments"
+  },
+  {
+    code: "ORB_T_EVENT_TYPE_WRONG_KIND",
+    category: "trait",
+    description: "An `emits` entry names a declared type that is not an Event type"
+  },
+  {
+    code: "ORB_P_UNKNOWN_PROTOCOL",
+    category: "page",
+    description: "A page names a protocol that is no row of the protocol table"
+  },
+  {
+    code: "ORB_P_ENDPOINT_GRANT_MISSING",
+    category: "page",
+    description: "An `http` endpoint has no covering `net` listen grant"
+  },
+  {
+    code: "ORB_P_ADDRESS_INVALID",
+    category: "page",
+    description: "A protocol page's address does not type-check against the protocol's address record"
+  },
+  {
+    code: "ORB_RUI_INVALID_ROW_ROUTE",
+    category: "render_ui",
+    description: "A data-grid/data-list row action `navigatesTo` is neither a literal path nor a quoted single-row lambda."
+  },
+  {
+    code: "ORB_RUI_UNKNOWN_ITEM_ACTION_PROP",
+    category: "render_ui",
+    description: "Unknown itemAction prop (e.g., hallucinated 'condition')"
+  },
+  {
+    code: "ORB_RUI_BINDING_TYPE_MISMATCH",
+    category: "render_ui",
+    description: "L2.1 keystone: render-ui prop bound to a `@payload.X` / `@entity.X` / `@config.X` / SExpression operator whose resolved type doesn't match any of the prop's declared `types` in the patterns registry. Distinct from `RenderUIPropTypeMismatch` (literal-only); this rule uses the F3 binding resolver to walk through bindings and SExpression operator return types (sharpened by F2's `returnSemantics` for input-dependent operators). Gap #6 in `docs/Almadar_Std_Verification.md`."
+  },
+  {
+    code: "ORB_RUI_EVENT_BINDING_PAYLOAD_MISMATCH",
+    category: "render_ui",
+    description: "L2.2: render-ui prop with `kind: \"event-ref\"` or `kind: \"callback\"` bound to an event-name string whose declared payload schema in the trait's `emits {}` block doesn't match the component's documented bus emit shape (registry's `emitPayloadSchema` for event-ref props; `callbackArgs` for callback props). Gap #32 in `docs/Almadar_Std_Verification.md`."
+  },
+  {
+    code: "ORB_CANCEL_CALL_NO_KEYED_CALL",
+    category: "effect",
+    description: "the app runs `cancel-call` but no `call-service` anywhere carries a `key`"
+  },
+  {
+    code: "ORB_CANCEL_CALL_KEY_NEVER_CALLED",
+    category: "effect",
+    description: "`--final`: a `cancel-call` on a `CallKey` (or a list of them) in a finished program where no keyed call has a `CallKey`-typed `key:`, so nothing the program runs is named by a key made with `as`"
+  },
+  {
+    code: "ORB_PAGE_FACTS_UNREQUESTED_READ",
+    category: "effect",
+    description: "an event reads a page fact the `browser/page-facts` call did not request"
+  },
+  {
+    code: "ORB_TAB_REQUEST_REFUSED",
+    category: "effect",
+    description: "a literal `browser/tab-*` request whose keys the op declares but whose values the kernel's tab-call parser refuses"
+  },
+  {
+    code: "ORB_X_DISPATCH_MIXED_RESIDENCE",
+    category: "effect",
+    description: "one dispatch's delegated effects reach browser-stored rows and server work"
+  },
+  {
+    code: "ORB_EFF_SLOT_CONFLICT",
+    category: "effect",
+    description: "Multiple render_ui effects targeting same slot"
+  },
+  {
+    code: "ORB_EFF_NOTIFY_RETIRED",
+    category: "effect",
+    description: "`notify` is sugar for `render-ui toast { type: alert, \u2026 }`, desugared at `.lolo` lowering (owner ruling 2026-09-11) \u2014 the `.orb` IR never carries a `notify` effect kind. A `notify` tuple reaching L2 means a hand-authored `.orb` or a registry not yet re-emitted."
+  },
+  {
+    code: "ORB_EMIT_DECLARED_BUT_UNFIRED",
+    category: "effect",
+    description: "Trait declares an event in its `emits[]` block but no transition fires it via `(emit X)` or operator emit-config success/failure. Usually a copy-paste leftover or a stale declaration after a rename; gap #2 defense in `docs/Almadar_Std_Verification.md`."
+  },
+  {
+    code: "ORB_EFF_MISSING_REQUIRED_EMIT",
+    category: "effect",
+    description: "Operator declares `requiresEmitSuccess: true` in canonical-operators.json but the effect call site is missing the trailing options object or its `emit.success` event key. Applies to fetch / persist / call-service by default; any future operator can opt in via the same JSON flag."
+  },
+  {
+    code: "SEXPR_ARITY_MISMATCH",
+    category: "sexpr",
+    description: "Wrong number of arguments for operator"
+  },
+  {
+    code: "SEXPR_LAMBDA_ARG_POSITION",
+    category: "sexpr",
+    description: "A `(fn \u2026)` form in an argument position the operator does not take its lambda in \u2014 decidable wrong argument order, e.g. `(array/reduce arr (fn \u2026) init)`"
+  },
+  {
+    code: "SEXPR_EFFECT_IN_GUARD",
+    category: "sexpr",
+    description: "Effect operator used in guard context"
+  },
+  {
+    code: "ORB_X_UNRESOLVED_PATTERN_FIELD_REF",
+    category: "cross",
+    description: "A pattern prop tagged `kind: 'field-ref'` (scalar) or `itemKind: 'field-ref'` (array element) carries a value that does not resolve to any field on the linked entity. Error severity. See Phase 3.2/3.3 in docs/Almadar_Agent_Behaviors_Plan.md."
+  },
+  {
+    code: "ORB_CONFIG_FIELD_REF_UNKNOWN",
+    category: "binding",
+    description: "A `field @entity` config knob names something that is not a field of the trait's bound entity"
+  },
+  {
+    code: "ORB_CONFIG_FIELD_REF_TYPE_MISMATCH",
+    category: "binding",
+    description: "A `field @entity T` config knob names a field whose type is not `T`"
+  },
+  {
+    code: "ORB_BINDING_INVALID_PATH",
+    category: "binding",
+    description: "Invalid binding path"
+  },
+  {
+    code: "ORB_X_SET_VALUE_TYPE_MISMATCH",
+    category: "effect",
+    description: "`(set @entity.X ?payloadField)` writes a payload field whose declared type does not match the target entity field's declared type. The lolo crate catches this at author time for `.lolo`; this is the raw-`.orb` defense-in-depth backstop. Payload field types are sourced from the trait's `emits[].payload_schema` and `listens` payload metadata."
+  },
+  {
+    code: "ORB_X_SET_RETURN_TYPE_MISMATCH",
+    category: "effect",
+    description: "`(set @entity.X (op \u2026))` assigns an operator/expression value whose inferred result type is incompatible with the target field's declared type (e.g. `(set @entity.count (str/concat \u2026))` into a `number` field). The value's type is inferred *through* the S-expression via the canonical operator `return_semantics` lattice; an unknowable result (`Json`) never rejects (Gap G-LOLO-SET-OP-RETURN)."
+  },
+  {
+    code: "ORB_X_COMPARISON_OPERAND_TYPE_MISMATCH",
+    category: "effect",
+    description: "An ordering comparison (`<`, `<=`, `>`, `>=`) whose operands infer to a number on one side and a string on the other. The JS runtime coerces, the compiled TypeScript does not typecheck, and Rust compares kinds \u2014 the paths disagree. Convert one side so both are the same kind."
+  },
+  {
+    code: "ORB_X_OPERATOR_ARG_TYPE_MISMATCH",
+    category: "effect",
+    description: 'An operator argument whose static type contradicts the type the operator table declares for its position \u2014 `(str/upper @entity.count)` with `count: number`, `(+ "a" 1)`. Both evaluators raise the same typed mismatch at run time (D-12), so the program can never do what it says.'
+  },
+  {
+    code: "ORB_OBJECT_PATH_UNDECLARED",
+    category: "effect",
+    description: "A literal path read through `object/get` (or another `key-of` operator) names a segment its first argument's declared type does not have: an empty segment, a record field the record does not declare, a non-numeric segment on a list or tuple, or a segment past a scalar. A Map takes any non-empty key segment. The read could only ever answer null or its default; a default does not excuse it. To read a key that contains a dot, escape the dot (`a\\.b`) or read the map with `object/pick`."
+  },
+  {
+    code: "ORB_X_OPERATOR_ARG_UNDETERMINED",
+    category: "effect",
+    description: "A value handed to an operator has no determined type \u2014 an unresolved expression, an expression value, json, a loose union, a list whose items share no type \u2014 so it cannot be checked against the type the operator declares (or, at a type variable, what the variable stands for and the type of the result are unknown). Narrow it with `(as value T)` (checked, null on a misfit), or give it a real type (a declared payload or entity shape, a named union alias for a list of differently-shaped items)."
+  },
+  {
+    code: "ORB_X_ORDERING_OPTIONAL_OPERAND",
+    category: "effect",
+    description: "An ordering comparison (`<`, `<=`, `>`, `>=`) over an operand that can be missing or null \u2014 an optional entity field with no default, an optional payload field \u2014 that the program neither guards with a presence check (`(and (validate/required x) (< x 3))`, an `if`/`when` on presence) nor declares a default for. Both evaluators read a missing value as below any number; every push-down store fails the comparison, so the meaning is the program's to state."
+  },
+  {
+    code: "ORB_X_OPERATOR_NULL_OPERAND",
+    category: "effect",
+    description: "An operand that can be missing or null \u2014 an optional entity field with no default, an optional payload field \u2014 handed to a position the kernel raises on when it is null (`rejectsNull` in the operator table), with no presence check or default in front of it. The program says what a missing value means: a guard, a default, or a required field."
+  },
+  {
+    code: "ORB_X_OPERATOR_OPTION_NEWER",
+    category: "effect",
+    description: "A call states an operator option that the installed operator table introduces in an orb release newer than the one running (`optionSince`), so this orb would refuse or ignore it at the host. Upgrade orb, or drop the option."
+  },
+  {
+    code: "ORB_X_SET_REQUIRED_FIELD_FROM_OPTIONAL_KNOB",
+    category: "effect",
+    description: "`(set @entity.X @config.<knob>)` where the value is STILL the literal `@config.<knob>` token post-inline (no default resolved it, no call-site override supplied one) and `X` is a REQUIRED entity field. The emitter has nothing honest to assign \u2014 a required TS slot gets `undefined`. Give the knob a default or make the field optional."
+  },
+  {
+    code: "ORB_EMIT_PAYLOAD_MISSING_REQUIRED",
+    category: "binding",
+    description: "`(emit EVT {...})` literal payload is missing a field the event's declared payload marks as required. Error severity."
+  },
+  {
+    code: "ORB_EMIT_PAYLOAD_EXTRA_FIELD",
+    category: "binding",
+    description: "`(emit EVT {...})` literal carries a field that is not declared on the event's payload schema. Error severity."
+  },
+  {
+    code: "ORB_EMIT_PAYLOAD_FIELD_TYPE_MISMATCH",
+    category: "binding",
+    description: "`(emit EVT {...})` literal provides a value whose primitive type does not match the declared `PayloadField.field_type`. Error severity."
+  },
+  {
+    code: "ORB_EMIT_REPEATS_IDENTICALLY",
+    category: "binding",
+    description: "An `emit` repeats an earlier one of the same transition identically: the dispatch loop collapses the second."
+  },
+  {
+    code: "ORB_X_ENTITY_PROP_CONTRACT",
+    category: "render_ui",
+    description: "A render-ui pattern prop typed `EntityWith<K>` declares required entity fields (`requiredFields` in the registry), but the bound entity does not provide them and no remap/field-map supplies them. The component would render blank rows. Remap-aware (runs post-inline). Error severity."
+  },
+  {
+    code: "ORB_EMIT_PAYLOAD_NOT_PRODUCED",
+    category: "binding",
+    description: "**The payload invariant.** An event's declared payload type IS its access path: declaring `Survey` means the payload is the row (read `?name`); declaring `{ row : Survey }` means read `?row.name`. This fires when an event declares a field that the effect firing it does not actually emit \u2014 so every read of that field is `undefined` at runtime, even though `orb validate` and `orb verify` otherwise pass. Checked as width subtyping (`declared \u2286 produced`): declaring FEWER fields than are emitted is legal, declaring one that is never emitted is not. Replaces the narrower `EmitSuccessPayloadWrapped` (persist-only) and `EmitSuccessPayloadReturnMismatch` (empty-payload-only) checks. Error severity."
+  },
+  {
+    code: "ORB_EFFECT_IN_LAMBDA",
+    category: "binding",
+    description: "An effect (`emit`, `persist`, `set`, `notify`, \u2026) inside the `fn` body of a collection operator: a lambda is evaluated for its value, an effect there never runs. Error severity."
+  },
+  {
+    code: "CIRCUIT_DEAD_END_COMPONENT",
+    category: "circuit",
+    description: "Interactive component missing itemActions"
+  },
+  {
+    code: "ORB_GEN_INVALID_REFERENCE",
+    category: "generic",
+    description: "Generic invalid reference format"
+  },
+  {
+    code: "ORB_GEN_MISSING_FIELD",
+    category: "generic",
+    description: "Generic missing required field"
+  },
+  {
+    code: "ORB_GEN_DUPLICATE",
+    category: "generic",
+    description: "Generic duplicate entity/item"
+  },
+  {
+    code: "CIRCUIT_ACTION_COMPONENT_MISMATCH",
+    category: "circuit",
+    description: "An item action is used on a component type that does not support that action"
+  },
+  {
+    code: "CIRCUIT_DEAD_END_STATE",
+    category: "circuit",
+    description: "A state has no outgoing transitions, so it is a dead end"
+  },
+  {
+    code: "CIRCUIT_DEAD_HANDLER",
+    category: "circuit",
+    description: "An item action fires an event into a state where no transition handles that event"
+  },
+  {
+    code: "CIRCUIT_DUPLICATE_EVENT",
+    category: "circuit",
+    description: "The same event is emitted by more than one action within a single render-ui effect"
+  },
+  {
+    code: "CIRCUIT_MODAL_EXIT_INCOMPLETE",
+    category: "circuit",
+    description: "A transition leaving a modal state does not close the modal overlay it opened"
+  },
+  {
+    code: "CIRCUIT_NO_OVERLAY_EXIT",
+    category: "circuit",
+    description: "A state renders into an overlay slot but has no exit transition, leaving users stuck"
+  },
+  {
+    code: "CIRCUIT_ORPHAN_EVENT",
+    category: "circuit",
+    description: "An action or emit raises an event that has no transition handler"
+  },
+  {
+    code: "CIRCUIT_UNREACHABLE_STATE",
+    category: "circuit",
+    description: "A state has no incoming transitions and cannot be reached"
+  },
+  {
+    code: "LINT_NODE_UNCHECKED",
+    category: "lint",
+    description: "A lint rule met a schema node of an unexpected shape and could not check it"
+  },
+  {
+    code: "ORB_A11Y_UNNAMED",
+    category: "a11y",
+    description: "A render-ui control has no accessible name, so screen readers announce it as unlabeled"
+  },
+  {
+    code: "ORB_ASSET_INLINE_URL",
+    category: "asset",
+    description: "A literal http(s) url sits in the config defaults or seed rows of an orbital that composes std-asset-pack."
+  },
+  {
+    code: "ORB_AUTH_GUARD_CLIENT_ONLY",
+    category: "auth",
+    description: "A transition guards on @user but its trait dispatches client-only, so the UI transition advances before the server evaluates the guard"
+  },
+  {
+    code: "ORB_BEACON_OPTION_UNKNOWN",
+    category: "beacon",
+    description: "A browser beacon request carries an option key that is not a known beacon request key"
+  },
+  {
+    code: "ORB_BEACON_TEXT_REQUIRED",
+    category: "browser",
+    description: "browser/beacon needs a request carrying a text field"
+  },
+  {
+    code: "ORB_BEACON_URL_NOT_ABSOLUTE",
+    category: "browser",
+    description: "A browser beacon effect targets a URL that is not an absolute http(s) URL"
+  },
+  {
+    code: "ORB_BINDING_DISPATCH_ROOT_IN_TICK",
+    category: "binding",
+    description: "A dispatch-only binding root is read inside a tick, where a firing has no delivery"
+  },
+  {
+    code: "ORB_BINDING_EMBED_READS_ARM_WRITE",
+    category: "binding",
+    description: "A transition writes a value and renders a child that reads it on mount, so the child shows the stale value"
+  },
+  {
+    code: "ORB_BINDING_ENTITY_FIELD_NEVER_SET",
+    category: "binding",
+    description: "A trait reads an entity binding field but no transition ever sets it, so it stays undefined"
+  },
+  {
+    code: "ORB_BINDING_ENTITY_FIELD_NOT_FOUND",
+    category: "binding",
+    description: "An @entity binding names a field that the linked entity does not declare"
+  },
+  {
+    code: "ORB_BINDING_EVENT_INVALID_PATH",
+    category: "binding",
+    description: "An @event binding path does not follow the shape of the delivery record"
+  },
+  {
+    code: "ORB_BINDING_FROM_ENTITY_OUTSIDE_ENSURES",
+    category: "binding",
+    description: "@fromEntity is the row before a transition and may only be used inside an @ensures"
+  },
+  {
+    code: "ORB_BINDING_INVALID_FORMAT",
+    category: "binding",
+    description: "A binding string is not in a valid binding format"
+  },
+  {
+    code: "ORB_BINDING_NOW_NO_PATH",
+    category: "binding",
+    description: "The @now binding is given a path, but it returns the current timestamp directly"
+  },
+  {
+    code: "ORB_BINDING_PAYLOAD_FIELD_UNDECLARED",
+    category: "binding",
+    description: "A @payload binding reads a field that the triggering event does not declare in its payload"
+  },
+  {
+    code: "ORB_BINDING_PAYLOAD_IN_TICK",
+    category: "binding",
+    description: "A binding reads @payload inside a tick, where a firing has no delivery"
+  },
+  {
+    code: "ORB_BINDING_PERSIST_ROW_ID_NEVER_SET",
+    category: "binding",
+    description: "A persist update or delete runs on an event but no transition sets the row id, so the write never touches a row"
+  },
+  {
+    code: "ORB_BINDING_ROOT_NO_PATH",
+    category: "binding",
+    description: "A binding root that takes no path is written with a path"
+  },
+  {
+    code: "ORB_BINDING_SET_TARGET_MISSING_PATH",
+    category: "binding",
+    description: "A set effect targets a binding root without a field path"
+  },
+  {
+    code: "ORB_BINDING_STATE_NO_PATH",
+    category: "binding",
+    description: "A binding root that returns a bare value, such as @state, is given a path"
+  },
+  {
+    code: "ORB_BINDING_TRAIT_CYCLE",
+    category: "binding",
+    description: "A cycle exists in @trait references"
+  },
+  {
+    code: "ORB_BINDING_TRAIT_INVALID_FORMAT",
+    category: "binding",
+    description: "A trait binding or trait-typed config default is not a valid trait reference"
+  },
+  {
+    code: "ORB_BINDING_TRAIT_INVALID_POSITION",
+    category: "binding",
+    description: "A @trait binding appears in a position other than a children array or a node-typed prop"
+  },
+  {
+    code: "ORB_BINDING_TRAIT_MISSING_NAME",
+    category: "binding",
+    description: "A @trait binding does not name the trait it refers to"
+  },
+  {
+    code: "ORB_BINDING_TRAIT_OUTSIDE_RENDER_UI",
+    category: "binding",
+    description: "An @trait binding appears outside a render-ui effect, where it is the only place trait references are allowed"
+  },
+  {
+    code: "ORB_BINDING_TRAIT_SELF_REFERENCE",
+    category: "binding",
+    description: "A trait references itself through a trait binding"
+  },
+  {
+    code: "ORB_BINDING_TRAIT_UNKNOWN",
+    category: "binding",
+    description: "A @trait binding references a trait that is not declared in this orbital"
+  },
+  {
+    code: "ORB_BINDING_UNKNOWN_ENTITY",
+    category: "binding",
+    description: "A binding refers to an entity that is not declared in the program"
+  },
+  {
+    code: "ORB_BINDING_UNKNOWN_ROOT",
+    category: "binding",
+    description: "A binding names a root the context does not provide"
+  },
+  {
+    code: "ORB_CALL_KEY_UNUSED",
+    category: "effect",
+    description: "A literal (as 'k' CallKey) names a key that no keyed call in the program runs under"
+  },
+  {
+    code: "ORB_CALL_SERVICE_CANCELLED_WITHOUT_KEY",
+    category: "call_service",
+    description: "A call-service declares emit.cancelled but has no key, so nothing can cancel an unkeyed call"
+  },
+  {
+    code: "ORB_CALL_SERVICE_KEY_DUPLICATE",
+    category: "effect",
+    description: "Two call-service effects in one transition use the same key"
+  },
+  {
+    code: "ORB_CALL_SERVICE_KEY_TYPE",
+    category: "call_service",
+    description: "A keyed call-service effect has a key that is not a non-empty string"
+  },
+  {
+    code: "ORB_CALL_SERVICE_RESULT_HAS_KEY",
+    category: "effect",
+    description: "A keyed call-service returns a record that already has a key field, so the call key would collide with it"
+  },
+  {
+    code: "ORB_CIRCUIT_ASYNC_RESULT_DEAF_TARGET",
+    category: "circuit",
+    description: "A transition declares async result events but its target state has no arm handling them, so the requester cannot hear its own result"
+  },
+  {
+    code: "ORB_CIRCUIT_DEAD_BODILESS_ACTION",
+    category: "circuit",
+    description: "A transition changes state but carries no effects, so the screen keeps its paint and affordances routed to it are dead"
+  },
+  {
+    code: "ORB_CIRCUIT_FAILURE_ARM_MISSING",
+    category: "circuit",
+    description: "A transition starting an asynchronous client call has no failure arm to handle its error"
+  },
+  {
+    code: "ORB_CIRCUIT_FAILURE_ARM_RENDERS_NOTHING",
+    category: "circuit",
+    description: "A state handles a failure event but its arm neither renders nor emits a declared event, so the failure reaches no one"
+  },
+  {
+    code: "ORB_CIRCUIT_INIT_UNCOVERED_STATE",
+    category: "circuit",
+    description: "A page trait handles INIT in its initial state but not in another reachable state, so revisiting the page from there does nothing"
+  },
+  {
+    code: "ORB_CIRCUIT_LIFECYCLE_EMIT_UNDELIVERED",
+    category: "circuit",
+    description: "A transition emits a lifecycle event that the event bus never delivers"
+  },
+  {
+    code: "ORB_CIRCUIT_MODAL_SHELL_CLOSE_DEAF",
+    category: "circuit",
+    description: "A state mounting an overlay-slot pattern has no CLOSE or CANCEL transition to dismiss it"
+  },
+  {
+    code: "ORB_CIRCUIT_OWN_EMIT_UNREACHABLE",
+    category: "circuit",
+    description: "A transition emits an event its own trait handles only from other states, so the same-trait cascade never delivers it from the target state"
+  },
+  {
+    code: "ORB_CIRCUIT_SELF_EMIT_LOOP",
+    category: "circuit",
+    description: "A transition re-emits its own trigger event with a constant payload and a same-event arm is reachable, so it loops forever"
+  },
+  {
+    code: "ORB_CIRCUIT_SELF_OVERLAY_IN_SHELL",
+    category: "circuit",
+    description: "A self-overlaying pattern is rendered inside an overlay slot payload, stacking two overlay chromes"
+  },
+  {
+    code: "ORB_CIRCUIT_VIEWER_STRANDED",
+    category: "circuit",
+    description: "A page's content owner repaints its region on a user-triggered event with a body that offers no way on"
+  },
+  {
+    code: "ORB_COMPOSED_STATE_UNREACHABLE",
+    category: "circuit",
+    description: "A composed trait can never enter some states because nothing in the program sends the events that enter them"
+  },
+  {
+    code: "ORB_COMPOSED_TRANSITION_UNREACHABLE",
+    category: "composed",
+    description: "A composed trait handles events that nothing in the program ever sends"
+  },
+  {
+    code: "ORB_COMPUTED_KEY_DOT_PATH",
+    category: "lint",
+    description: "object/set, object/get or object/has on a Map field with a str/concat key containing a literal dot: the key is read as a dot path, so the value nests instead of being one map entry"
+  },
+  {
+    code: "ORB_CONFIG_DANGLING_REF",
+    category: "binding",
+    description: "An @config key is not declared by any config schema reachable from the trait chain"
+  },
+  {
+    code: "ORB_CONTROL_NO_CONSEQUENCE",
+    category: "emit",
+    description: "A rendered control fires an event whose handlers change nothing the app or the viewer can observe."
+  },
+  {
+    code: "ORB_CONTROL_VALUE_DISCARDED",
+    category: "circuit",
+    description: "A composed trait's rendered control fires an event carrying a value that no other trait hears and whose own handling reads none of it: the value the user entered is discarded (a form submission nothing keeps)."
+  },
+  {
+    code: "ORB_CREDENTIAL_REQUEST_INVALID",
+    category: "credential",
+    description: "A credential request host effect carries options other than the ones it declares"
+  },
+  {
+    code: "ORB_DERIVED_FIELD_WRITTEN",
+    category: "entity_mutation",
+    description: "A set or persist writes an @derived field that the kernel computes on every write"
+  },
+  {
+    code: "ORB_EFFECT_OPTION_DROPPED",
+    category: "effect",
+    description: "An effect carries options that depend on a key echo, but the effect has no key so the options are dropped"
+  },
+  {
+    code: "ORB_EFF_CALL_SERVICE_MISSING_ACTION",
+    category: "effect",
+    description: "A call-service effect has no string action"
+  },
+  {
+    code: "ORB_EFF_CALL_SERVICE_MISSING_PARAM",
+    category: "effect",
+    description: "A call-service effect omits a parameter the service action requires"
+  },
+  {
+    code: "ORB_EFF_CALL_SERVICE_MISSING_SERVICE",
+    category: "effect",
+    description: "A call_service effect is missing its service name or action"
+  },
+  {
+    code: "ORB_EFF_CALL_SERVICE_PARAM_TYPE",
+    category: "effect",
+    description: "A call-service parameter has a value whose type does not match the type the service action declares"
+  },
+  {
+    code: "ORB_EFF_CALL_SERVICE_UNKNOWN_PARAM",
+    category: "effect",
+    description: "A call-service passes a param that the service action does not declare"
+  },
+  {
+    code: "ORB_EFF_CALL_SERVICE_UNKNOWN_SERVICE",
+    category: "effect",
+    description: "A call-service effect names a service that is not a registered integrator or declared service"
+  },
+  {
+    code: "ORB_EFF_EMIT_INVALID_NAME",
+    category: "effect",
+    description: "The event name inside an emit effect is not a valid string event name"
+  },
+  {
+    code: "ORB_EFF_EMIT_KEY_INVALID",
+    category: "effect",
+    description: "An emit config carries a key that the operator does not support"
+  },
+  {
+    code: "ORB_EFF_EMIT_UNDECLARED_EVENT",
+    category: "effect",
+    description: "An event named in emit is not declared in the trait's emits array"
+  },
+  {
+    code: "ORB_EFF_FETCH_BY_ID_PAYLOAD_LIST",
+    category: "effect",
+    description: "A fetch by id effect takes its id from a payload that is a list rather than a single value"
+  },
+  {
+    code: "ORB_EFF_FETCH_INVALID_ENTITY",
+    category: "effect",
+    description: "A fetch effect is missing an entity name or references an invalid entity"
+  },
+  {
+    code: "ORB_EFF_FETCH_INVALID_INCLUDE",
+    category: "effect",
+    description: "A fetch includes a relation that the fetched entity has no relation field for"
+  },
+  {
+    code: "ORB_EFF_FETCH_INVALID_OPTION",
+    category: "effect",
+    description: "A fetch deliver option is not one of the allowed values rows or ids"
+  },
+  {
+    code: "ORB_EFF_MISSING_FETCH_FOR_ENTITY",
+    category: "effect",
+    description: "A render-ui references an entity but no fetch effect for it exists in this or any predecessor transition"
+  },
+  {
+    code: "ORB_EFF_NAVIGATE_MISSING_PAYLOAD",
+    category: "effect",
+    description: "A navigate effect omits a payload field the target page requires for its INIT event"
+  },
+  {
+    code: "ORB_EFF_NAVIGATE_TARGET_UNREACHABLE",
+    category: "effect",
+    description: "A navigate target path does not resolve to any declared page"
+  },
+  {
+    code: "ORB_EFF_PROGRAM_EVAL_FAILURE_MISSING",
+    category: "effect",
+    description: "program/eval carries no emit.failure event, so validator errors would be dropped"
+  },
+  {
+    code: "ORB_EFF_RETIRED_FORM",
+    category: "effect",
+    description: "An effect is written in a retired object form instead of the array form"
+  },
+  {
+    code: "ORB_EFF_SET_INVALID_BINDING",
+    category: "effect",
+    description: "A set effect is missing its binding or its value"
+  },
+  {
+    code: "ORB_EFF_SET_PAYLOAD_NOT_ALLOWED",
+    category: "effect",
+    description: "A set effect targets @payload, which is read-only; it should target @entity"
+  },
+  {
+    code: "ORB_EFF_UNKNOWN_TYPE",
+    category: "effect",
+    description: "An effect has an unknown type or is malformed"
+  },
+  {
+    code: "ORB_EFF_UNSIGNED_NOT_ENV_GUARDED",
+    category: "effect",
+    description: "A jws/verify call with a literal allowUnsigned true sits in a transition that is not env-guarded"
+  },
+  {
+    code: "ORB_EMBED_CONFIG_FORWARD_MULTI_REFERRER",
+    category: "embed",
+    description: "A trait that forwards @config is embedded by more than one referrer, so the forwarded value is ambiguous"
+  },
+  {
+    code: "ORB_EMIT_CONFIG_REF_INVALID",
+    category: "effect",
+    description: "An emit config reference is invalid"
+  },
+  {
+    code: "ORB_EMIT_CONTROL_UNHANDLED",
+    category: "emit",
+    description: "A rendered control fires an event nothing handles or routes."
+  },
+  {
+    code: "ORB_EMIT_UNROUTED_TO_HANDLER",
+    category: "trait_event",
+    description: "A trait emits an event another trait has an arm for, but no declared listens route delivers it"
+  },
+  {
+    code: "ORB_ENTITY_INTRINSIC_FIELD_PERSISTED",
+    category: "entity_mutation",
+    description: "A persist data literal names an @intrinsic field, which is trait-owned view-state and never a persisted column"
+  },
+  {
+    code: "ORB_ENTITY_OWNER_COLUMN_UNSCOPED",
+    category: "entity",
+    description: "An entity declares owner columns but has no access policy scoping rows to the owner"
+  },
+  {
+    code: "ORB_ENTITY_SPLIT_MUTATION",
+    category: "entity_mutation",
+    description: "A runtime entity is mutated by several traits on isolated per-trait copies while another trait reads a field it never writes"
+  },
+  {
+    code: "ORB_E_DUPLICATE_FIELD",
+    category: "entity",
+    description: "An entity declares the same field name more than once"
+  },
+  {
+    code: "ORB_E_EMPTY_ENUM_VALUES",
+    category: "entity",
+    description: "An enum field declares no values"
+  },
+  {
+    code: "ORB_E_IDENTITY_LOCAL",
+    category: "entity",
+    description: "An identity entity is declared as browser-stored, but the viewer directory is never browser-resident"
+  },
+  {
+    code: "ORB_E_INSTANCE_INVALID",
+    category: "entity",
+    description: "An entity instance row sets a key that is not a field of the entity"
+  },
+  {
+    code: "ORB_E_INVALID_FIELD_NAME",
+    category: "entity",
+    description: "An entity field or entity name is empty or not in the required naming form"
+  },
+  {
+    code: "ORB_E_INVALID_FIELD_TYPE",
+    category: "entity",
+    description: "An entity field declares a type that is not a valid field type"
+  },
+  {
+    code: "ORB_E_INVALID_RELATION",
+    category: "entity",
+    description: "A relation field is missing its relation configuration or points at an entity that does not exist"
+  },
+  {
+    code: "ORB_E_LITERAL_UNION_DEFAULT_MISMATCH",
+    category: "entity",
+    description: "A field default is not one of the values of its declared literal union"
+  },
+  {
+    code: "ORB_E_LOCALE_INSTANCES_INCOMPLETE",
+    category: "entity",
+    description: "An entity writes rows per locale but has no default instances block for its default locale"
+  },
+  {
+    code: "ORB_E_LOCALE_INSTANCES_NOT_LOCAL",
+    category: "entity",
+    description: "An entity writes rows per locale but its rows are not browser-stored, so every viewer shares them"
+  },
+  {
+    code: "ORB_E_LOCALE_INSTANCES_UNKNOWN_LOCALE",
+    category: "entity",
+    description: "An entity writes locale instances for a locale that is not among the declared locales"
+  },
+  {
+    code: "ORB_E_LOCAL_REQUIRES_PERSISTENT",
+    category: "entity",
+    description: "A runtime entity declares a browser storage location, which only applies to persistent entities"
+  },
+  {
+    code: "ORB_E_MERGED_FIELD_UNREFERENCED",
+    category: "entity",
+    description: "A field merged into an entity is never read, written, fetch-included or persisted by any trait of the orbital"
+  },
+  {
+    code: "ORB_E_MISSING_COLLECTION",
+    category: "entity",
+    description: "A persistent entity does not declare a collection name"
+  },
+  {
+    code: "ORB_E_MISSING_NAME",
+    category: "entity",
+    description: "An entity is missing its required name"
+  },
+  {
+    code: "ORB_E_MOCK_NOT_IN_ENUM",
+    category: "entity",
+    description: "Mock candidate values are not values of the enum field they belong to"
+  },
+  {
+    code: "ORB_E_NO_FIELDS",
+    category: "entity",
+    description: "An entity declares no fields and must have at least one"
+  },
+  {
+    code: "ORB_E_SEMANTIC_VALUE_INVALID",
+    category: "entity",
+    description: "A semantically typed field has a default value that is invalid for its kind, such as an empty string"
+  },
+  {
+    code: "ORB_FETCH_DELIVER_IDS_ENTITY_REFS",
+    category: "fetch",
+    description: "A fetch using deliver ids also asks for included relations, but ids delivers no rows to carry them"
+  },
+  {
+    code: "ORB_FETCH_DELIVER_IDS_NO_SUCCESS",
+    category: "effect",
+    description: "A fetch with deliver ids has no emit.success, so nothing carries the reference"
+  },
+  {
+    code: "ORB_FETCH_DELIVER_IDS_ROWS_READ",
+    category: "effect",
+    description: "A fetch with deliver ids delivers a row-set reference as the success event's data; any use other than passing it whole as a render-ui prop value reads rows that were never delivered"
+  },
+  {
+    code: "ORB_FETCH_NEEDS_COMPOSITE_INDEX",
+    category: "effect",
+    description: "A fetch query needs a composite index that the store driver does not create and no index declaration covers"
+  },
+  {
+    code: "ORB_FETCH_TOTAL_NONE_READ",
+    category: "effect",
+    description: "A fetch with total none skips the count, so the success event's totalCount is never set and may not be read"
+  },
+  {
+    code: "ORB_FETCH_UNINDEXED",
+    category: "query",
+    description: "A fetch filter cannot be pushed down by the store driver and no @index covers it, so the kernel scans every row"
+  },
+  {
+    code: "ORB_GEN_INVALID_VALUE",
+    category: "generic",
+    description: "A value is invalid for the position it is written in"
+  },
+  {
+    code: "ORB_GUARD_ON_FRAME_FIELD_AUTHORIZES",
+    category: "guard",
+    description: "A guard reads an intrinsic frame field of an entity to authorize, but intrinsic fields are not trustworthy for access"
+  },
+  {
+    code: "ORB_GUEST_VIEW_NOT_CLIENT",
+    category: "trait",
+    description: "A trait that does not run on the client paints a guest-view, so the kernel cannot route a click inside the guest"
+  },
+  {
+    code: "ORB_HOST_EFFECT_ARITY",
+    category: "effect",
+    description: "A host effect is called with the wrong number of arguments"
+  },
+  {
+    code: "ORB_HOST_EFFECT_OPTION_UNKNOWN",
+    category: "host_effect",
+    description: "A host effect is given an option outside the set of options it accepts"
+  },
+  {
+    code: "ORB_HTTP_EGRESS_ENTRY_INVALID",
+    category: "http",
+    description: "An egress allowlist entry is not of the form scheme://host[:port]"
+  },
+  {
+    code: "ORB_HTTP_EGRESS_UNDECLARED",
+    category: "http",
+    description: "An outbound request targets an origin that is not declared in the program egress list"
+  },
+  {
+    code: "ORB_HTTP_ORIGIN_NOT_STATIC",
+    category: "http",
+    description: "An http origin is not a string literal or a url-typed config knob, so egress cannot be checked"
+  },
+  {
+    code: "ORB_ID_AUTHORED_WITHOUT_LEDGER",
+    category: "id",
+    description: "An id is authored in source without a matching ledger entry, so it is replaced on load"
+  },
+  {
+    code: "ORB_ID_DUPLICATE_EVENT_ID",
+    category: "id",
+    description: "An event id is declared by more than one trait, but ids must be document-unique"
+  },
+  {
+    code: "ORB_ID_KIND_MISMATCH",
+    category: "id",
+    description: "An id of one kind is used in a position that requires an id of a different kind"
+  },
+  {
+    code: "ORB_ID_LEDGER_ORPHAN",
+    category: "id",
+    description: "An id ledger row is carried by no node in the schema and is stale"
+  },
+  {
+    code: "ORB_ID_NAME_MISMATCH",
+    category: "id",
+    description: "A name in the source disagrees with the current name the ledger records for the same id"
+  },
+  {
+    code: "ORB_ID_UNKNOWN_REF",
+    category: "id",
+    description: "An id reference matches no arena node or ledger entry"
+  },
+  {
+    code: "ORB_INBOUND_ANSWER_FOREIGN",
+    category: "inbound",
+    description: "A trait other than an inbound handler emits the handler's answer event, so the answer never reaches the caller"
+  },
+  {
+    code: "ORB_INBOUND_ANSWER_UNDECLARED",
+    category: "inbound",
+    description: "An inbound hook event answers with an event the trait does not declare in emits"
+  },
+  {
+    code: "ORB_INBOUND_DUPLICATE",
+    category: "inbound",
+    description: "An inbound hook has more than one handler"
+  },
+  {
+    code: "ORB_INBOUND_ENTRY_INVALID",
+    category: "inbound",
+    description: "An inbound entry is not a valid hook name"
+  },
+  {
+    code: "ORB_INBOUND_UNDECLARED",
+    category: "inbound",
+    description: "An event handles an inbound hook that the program's inbound block does not declare"
+  },
+  {
+    code: "ORB_INBOUND_VERIFY_INVALID",
+    category: "inbound",
+    description: "An inbound hook verifies a header against a credential, but the header is not a lower-case header name or the credential is not a credential name"
+  },
+  {
+    code: "ORB_INDEX_PATH_DUPLICATE",
+    category: "index",
+    description: "The same index path, with the same ordering, is declared more than once on an entity"
+  },
+  {
+    code: "ORB_INDEX_PATH_INVALID",
+    category: "entity",
+    description: "An index path names a field that the entity does not declare"
+  },
+  {
+    code: "ORB_JSON_ROUNDTRIP",
+    category: "lint",
+    description: "json/parse re-parses what json/stringify just serialized; a stringify\u2192parse round trip launders a value's type past the checker (owner hard rule, CLAUDE.md). Narrow with `as`."
+  },
+  {
+    code: "ORB_LINT_FINDING_CODE_UNDECLARED",
+    category: "lint",
+    description: "A lint rule names a finding code that its declared codes record does not carry."
+  },
+  {
+    code: "ORB_LINT_INDEX_MISSING",
+    category: "lint",
+    description: "The lint input arrived without a shared program fact the rule reads (the structural index, sites, units, embeds or entities), so the rule cannot check the program"
+  },
+  {
+    code: "ORB_LINT_INPUT_UNREAD",
+    category: "lint",
+    description: "A lint input file could not be read or lowered, so the lint rules did not run"
+  },
+  {
+    code: "ORB_LINT_LANGUAGE_FACTS_UNREAD",
+    category: "lint",
+    description: "The installed language facts could not be read, so the lint rule could not check what it needs"
+  },
+  {
+    code: "ORB_LINT_OPERATOR_SHAPES_UNREAD",
+    category: "lint",
+    description: "The installed operator table could not be read or does not match the operator shape type, so a lint cannot run"
+  },
+  {
+    code: "ORB_LINT_RULE_COUNT_MISMATCH",
+    category: "lint",
+    description: "A lint engine's rules or programOnlyRules names differ from the rule names its routed rule traits answer LINT_FOUND with"
+  },
+  {
+    code: "ORB_LINT_RULE_FAILED",
+    category: "lint",
+    description: "A lint rule met an input its own preconditions exclude and could not check it"
+  },
+  {
+    code: "ORB_LINT_SERVICE_REGISTRY_UNREAD",
+    category: "lint",
+    description: "The installed services registry could not be read, so call-service services cannot be checked"
+  },
+  {
+    code: "ORB_LINT_UI_VOCAB_UNREAD",
+    category: "lint",
+    description: "The installed @almadar/core declares no readable UI vocabulary, so a UI lint check cannot run"
+  },
+  {
+    code: "ORB_LISTEN_REDUNDANT_EMBED_ROUTE",
+    category: "listen",
+    description: "A listens route is redundant because the embedded trait already receives that event"
+  },
+  {
+    code: "ORB_LISTEN_ROUTE_STARVES_REQUIRED_FIELD",
+    category: "trait_event",
+    description: "A listens route requires a payload field that the source event contract never produces"
+  },
+  {
+    code: "ORB_LISTEN_WILDCARD_UNKEYED",
+    category: "trait_event",
+    description: "A wildcard listens route hears every caller's event but its guard never reads the call key in the payload"
+  },
+  {
+    code: "ORB_MEM_ALIAS",
+    category: "mem",
+    description: "An exclusive borrow of a block while another borrow of it is live, or a borrow while an exclusive one is live"
+  },
+  {
+    code: "ORB_MEM_DOUBLE_FREE",
+    category: "mem",
+    description: "A handle is freed, dropped or released a second time on some path"
+  },
+  {
+    code: "ORB_MEM_LEAK",
+    category: "mem",
+    description: "An arena reaches a resting state on some path without being dropped"
+  },
+  {
+    code: "ORB_MEM_USE_AFTER_FREE",
+    category: "mem",
+    description: "A mem/ call takes a handle after it was freed, dropped or released on some path"
+  },
+  {
+    code: "ORB_NAV_TARGET_UNDECLARED",
+    category: "page",
+    description: "A navigation target stated as a literal path (a navigate effect, a navItems or link href, a navigatesTo) names no page the finished program declares"
+  },
+  {
+    code: "ORB_OAUTH_CLIENT_INVALID",
+    category: "oauth",
+    description: "An OAuth client block uses a key that is not a valid OAuth client key"
+  },
+  {
+    code: "ORB_OAUTH_OPTION_UNKNOWN",
+    category: "oauth",
+    description: "An oauth-authorize call passes an option that is not recognized"
+  },
+  {
+    code: "ORB_OAUTH_PROVIDER_UNKNOWN",
+    category: "oauth",
+    description: "The OAuth clients map is keyed by something other than a known provider tag"
+  },
+  {
+    code: "ORB_ON_DEVICE_EFFECT_ON_SERVER",
+    category: "browser",
+    description: "An on-device model effect runs in a background tick on the server, which has no on-device model"
+  },
+  {
+    code: "ORB_ON_DEVICE_SCHEMA_INVALID",
+    category: "browser",
+    description: "A browser prompt response schema is not valid JSON Schema text describing a JSON object"
+  },
+  {
+    code: "ORB_OP_INVALID_TIME_UNIT",
+    category: "operator",
+    description: "A time operator is given a unit that is not an accepted time unit"
+  },
+  {
+    code: "ORB_OS_EGRESS_SCHEME_UNUSED",
+    category: "os",
+    description: "An egress entry whose scheme (redis, rediss, postgres, postgresql) no operator or fetch uses since the TCP protocol-target grants were retired; its net-grant replacement is named"
+  },
+  {
+    code: "ORB_OS_GRANT_ENTRY_INVALID",
+    category: "os",
+    description: "A declared grant entry that can match nothing"
+  },
+  {
+    code: "ORB_OS_GRANT_MISSING",
+    category: "os",
+    description: "An os/ call that the grants of its orbital (app level plus its own) do not cover"
+  },
+  {
+    code: "ORB_OS_GRANT_UNUSED",
+    category: "os",
+    description: "A granted entry that no os/ call of the orbital (or of the program, at app level) uses; a warning"
+  },
+  {
+    code: "ORB_OS_TARGET_NOT_STATIC",
+    category: "os",
+    description: "An os/ call target that is computed, so its grant cannot be checked at build time"
+  },
+  {
+    code: "ORB_O_CONFIG_DEAD_KNOB",
+    category: "orbital",
+    description: "A declared app-level config knob is not forwarded by any trait config default, so it has no effect"
+  },
+  {
+    code: "ORB_O_CONFIG_UNKNOWN_KEY",
+    category: "orbital_ref",
+    description: "A call-site config key matches no config knob declared by the upstream orbital"
+  },
+  {
+    code: "ORB_O_DUPLICATE_NAME",
+    category: "orbital",
+    description: "Two or more orbitals in a program share the same name"
+  },
+  {
+    code: "ORB_O_DUPLICATE_USE_ALIAS",
+    category: "orbital",
+    description: "Two uses imports share the same alias"
+  },
+  {
+    code: "ORB_O_ENTITY_EXPECT_AMBIGUOUS",
+    category: "orbital_ref",
+    description: "An entity an imported orbital expects of a sibling is provided by several sibling imports and no entities entry binds it"
+  },
+  {
+    code: "ORB_O_ENTITY_PERSISTENCE_LOCKED",
+    category: "orbital",
+    description: "An entity persistence or collection override on an orbital reference has no effect because the primary entity locks it"
+  },
+  {
+    code: "ORB_O_ENTITY_TARGET_UNKNOWN",
+    category: "orbital_ref",
+    description: "An entities value names no entity the consumer schema declares"
+  },
+  {
+    code: "ORB_O_ENTITY_UNKNOWN_KEY",
+    category: "orbital_ref",
+    description: "An entities key names no entity in the upstream out-of-orbital closure"
+  },
+  {
+    code: "ORB_O_ENTITY_UNMAPPED",
+    category: "orbital_ref",
+    description: "A kept trait, relation or page references an out-of-orbital entity that entities {} never maps"
+  },
+  {
+    code: "ORB_O_EXTEND_FIELD_COLLISION",
+    category: "orbital_ref",
+    description: "An extend field collides with a field already declared on the upstream primary entity"
+  },
+  {
+    code: "ORB_O_EXTEND_FIELD_UNREAD",
+    category: "orbital",
+    description: "A field added by an extend block is never read, set, rendered or forwarded by a config knob"
+  },
+  {
+    code: "ORB_O_FIELD_RENAME_UNAPPLIED",
+    category: "orbital_ref",
+    description: "A fields rename left the pre-rename field name in a config default position the rewrite does not reach"
+  },
+  {
+    code: "ORB_O_MOCK_UNKNOWN_FIELD",
+    category: "orbital",
+    description: "A mock block names a field the entity materialized from the referenced orbital does not declare"
+  },
+  {
+    code: "ORB_O_OMIT_EMBEDDED_TRAIT",
+    category: "orbital",
+    description: "An orbital reference omits a trait that another kept trait embeds"
+  },
+  {
+    code: "ORB_O_PAGE_UNKNOWN_PATH",
+    category: "orbital_ref",
+    description: "A pages or mounts key names a page path that the upstream orbital does not declare"
+  },
+  {
+    code: "ORB_O_RETYPE_FIELD_CONFLICT",
+    category: "orbital",
+    description: "A field is both retyped and added by extend in the same orbital reference"
+  },
+  {
+    code: "ORB_O_RETYPE_UNKNOWN_FIELD",
+    category: "orbital",
+    description: "A retype block names a field the entity materialized from the referenced orbital does not declare"
+  },
+  {
+    code: "ORB_O_ROLE_TARGET_NOT_MEMBER",
+    category: "orbital_ref",
+    description: "A roles target is not a member of the consumer roster field vocabulary"
+  },
+  {
+    code: "ORB_O_ROLE_UNKNOWN_UPSTREAM",
+    category: "orbital_ref",
+    description: "A roles key names no value in any upstream identity field vocabulary"
+  },
+  {
+    code: "ORB_O_TRAITS_OMITTED_TRAIT",
+    category: "orbital",
+    description: "A traits override names a trait that omit or only drops from the imported orbital"
+  },
+  {
+    code: "ORB_O_TRAITS_UNKNOWN_TRAIT",
+    category: "orbital_ref",
+    description: "A traits key names a trait that the upstream orbital does not have"
+  },
+  {
+    code: "ORB_PAGE_AMBIGUOUS_CONTENT_OWNER",
+    category: "page",
+    description: "Several traits each render a content body into the main slot and none composes the others, so the page has no single content owner"
+  },
+  {
+    code: "ORB_PAGE_CONTROL_OUTSIDE_SHELL",
+    category: "page",
+    description: "A trait paints a control into the main slot of a page whose shell shows another trait as its content, and nothing there embeds it"
+  },
+  {
+    code: "ORB_PAGE_FACTS_FIELD_INVALID",
+    category: "page",
+    description: "A browser/page-facts effect declares no facts"
+  },
+  {
+    code: "ORB_PAGE_NOT_FOUND_DUPLICATE",
+    category: "page",
+    description: "A program declares more than one [notFound] page."
+  },
+  {
+    code: "ORB_PAGE_NOT_FOUND_MISSING",
+    category: "page",
+    description: "A program with route pages declares no [notFound] page."
+  },
+  {
+    code: "ORB_PAGE_SECOND_CONTENT_BODY",
+    category: "page",
+    description: "More than one trait on a page renders a content body into the main slot"
+  },
+  {
+    code: "ORB_PAGE_UNREACHABLE",
+    category: "page",
+    description: "A page is declared but appears in no link, navItems entry or navigate effect"
+  },
+  {
+    code: "ORB_PERSIST_BATCH_BAD_OP",
+    category: "persist",
+    description: "A persist batch contains an operation that is not valid in a batch"
+  },
+  {
+    code: "ORB_PERSIST_BATCH_MIXED_PLACEMENT",
+    category: "persist",
+    description: "A persist batch writes both browser-stored and server-stored entities in one effect, which no single executor can hold"
+  },
+  {
+    code: "ORB_PERSIST_BATCH_OPS_NOT_ARRAY",
+    category: "persist",
+    description: "A persist batch operations expression is missing or not array-typed"
+  },
+  {
+    code: "ORB_PERSIST_CREATE_LITERAL_ID",
+    category: "persist",
+    description: "A persist create names a literal id, so a second run fails with a duplicate id"
+  },
+  {
+    code: "ORB_PERSIST_CREATE_MISSING_POLICY_FIELD",
+    category: "persist",
+    description: "A persist create data literal omits a field its entity's create access policy compares, so the row can never satisfy the policy"
+  },
+  {
+    code: "ORB_PERSIST_ID_NOT_A_PATH",
+    category: "persist",
+    description: "A persist effect names its row id with an expression instead of a binding path or literal id, so no row key resolves"
+  },
+  {
+    code: "ORB_PERSIST_WHERE_NOT_A_PREDICATE",
+    category: "persist",
+    description: "A persist where clause is not a valid row predicate"
+  },
+  {
+    code: "ORB_PLACEMENT_ORBITAL_DUPLICATE",
+    category: "placement",
+    description: "An orbital is placed more than once in the deployment"
+  },
+  {
+    code: "ORB_PLACEMENT_ORBITAL_UNKNOWN",
+    category: "placement",
+    description: "A deployment unit lists an orbital name that is not an orbital of the program"
+  },
+  {
+    code: "ORB_PLACEMENT_ORBITAL_UNPLACED",
+    category: "placement",
+    description: "A deployment is declared but an orbital belongs to none of its units"
+  },
+  {
+    code: "ORB_PLACEMENT_UNIT_EMPTY",
+    category: "placement",
+    description: "A deployment unit lists no orbital"
+  },
+  {
+    code: "ORB_P_AUTH_NO_SIGN_IN",
+    category: "page",
+    description: "A page requires authenticated access but the app declares no signIn route"
+  },
+  {
+    code: "ORB_P_DUPLICATE_PATH",
+    category: "page",
+    description: "Two pages declare the same path after normalization"
+  },
+  {
+    code: "ORB_P_EMPTY_TRAITS",
+    category: "page",
+    description: "A page declares an empty traits array"
+  },
+  {
+    code: "ORB_P_HOST_RESERVED_ROUTE",
+    category: "page",
+    description: "A page is declared on the host's reserved sign-in route"
+  },
+  {
+    code: "ORB_P_INDEX_PARAM_ROUTE",
+    category: "page",
+    description: "A parameter-route page is marked indexing index although its concrete URLs are not declared"
+  },
+  {
+    code: "ORB_P_INDEX_REQUIRES_PUBLIC",
+    category: "page",
+    description: "A page declares indexing: index but lacks the public access it requires"
+  },
+  {
+    code: "ORB_P_INVALID_PATH",
+    category: "page",
+    description: "A page or navigate path does not start with a slash"
+  },
+  {
+    code: "ORB_P_INVALID_TRAIT_REF",
+    category: "page",
+    description: "A page's inline trait reference has no name"
+  },
+  {
+    code: "ORB_P_INVALID_VIEW_TYPE",
+    category: "page",
+    description: "A page declares a view type that is not a valid view type"
+  },
+  {
+    code: "ORB_P_MISSING_NAME",
+    category: "page",
+    description: "A page does not declare a name"
+  },
+  {
+    code: "ORB_P_MISSING_PATH",
+    category: "page",
+    description: "A page is missing its required path"
+  },
+  {
+    code: "ORB_P_MISSING_TRAITS",
+    category: "page",
+    description: "A page has no traits array for trait-driven UI"
+  },
+  {
+    code: "ORB_P_SIGN_IN_UNKNOWN_ROUTE",
+    category: "page",
+    description: "The app's signIn route names a path that is no page of the app"
+  },
+  {
+    code: "ORB_P_TRANSLATION_DUPLICATE_LOCALE",
+    category: "page",
+    description: "A translation group holds more than one page in the same locale"
+  },
+  {
+    code: "ORB_RANDOM_BYTES_COUNT",
+    category: "random",
+    description: "A random-bytes count argument is outside the allowed integer range"
+  },
+  {
+    code: "ORB_RENDER_ACTION_LIFECYCLE_EVENT",
+    category: "render_ui",
+    description: "A rendered pattern prop targets a lifecycle event that the bus never delivers"
+  },
+  {
+    code: "ORB_RENDER_GROUPBY_ENUM_COLUMN_GAP",
+    category: "render_ui",
+    description: "A groupBy column set omits enum values of the field, so rows with those values match no column and disappear"
+  },
+  {
+    code: "ORB_RENDER_ORBITAL_VALUE_EMBEDDED",
+    category: "render_ui",
+    description: "A render-ui embeds an orbital value, but only trait values can be rendered"
+  },
+  {
+    code: "ORB_RENDER_UNBOUND_TRAIT_KNOB_EMBEDDED",
+    category: "render_ui",
+    description: "A render-ui embeds a trait-typed value that may be unbound without a guard, so it renders nothing"
+  },
+  {
+    code: "ORB_RUI_CHILD_NOT_DRAWABLE",
+    category: "render_ui",
+    description: "A non-drawable child is composed under a canvas draw-host, which paints only neutral drawable descriptors"
+  },
+  {
+    code: "ORB_RUI_ELEMENT_SHAPE_MISMATCH",
+    category: "render_ui",
+    description: "An element of a pattern prop is missing a field required by the pattern's element shape"
+  },
+  {
+    code: "ORB_RUI_FORM_FIELD_INTRINSIC",
+    category: "render_ui",
+    description: "A form pattern offers an input for an intrinsic entity field, which is never persisted so the input is discarded"
+  },
+  {
+    code: "ORB_RUI_INVALID_FIELD_PATH",
+    category: "render_ui",
+    description: "A nested field path references an invalid relation or field"
+  },
+  {
+    code: "ORB_RUI_INVALID_ITEM_ACTION",
+    category: "render_ui",
+    description: "An itemAction configuration on a rendered pattern is invalid"
+  },
+  {
+    code: "ORB_RUI_INVALID_PATTERN",
+    category: "render_ui",
+    description: "A render-ui pattern type is not in the pattern registry"
+  },
+  {
+    code: "ORB_RUI_INVALID_PROP",
+    category: "render_ui",
+    description: "A render-ui pattern is given a prop that the pattern does not define"
+  },
+  {
+    code: "ORB_RUI_INVALID_SLOT",
+    category: "render_ui",
+    description: "A render-ui effect targets an invalid slot"
+  },
+  {
+    code: "ORB_RUI_MISSING_ACTION",
+    category: "render_ui",
+    description: "A render-ui pattern that needs an interaction target has no action, onClick, event or href"
+  },
+  {
+    code: "ORB_RUI_MISSING_PATTERN_TYPE",
+    category: "render_ui",
+    description: "A render-ui pattern has no type property"
+  },
+  {
+    code: "ORB_RUI_MISSING_REQUIRED_PROP",
+    category: "render_ui",
+    description: "A render-ui pattern is missing a prop that the pattern requires"
+  },
+  {
+    code: "ORB_RUI_PROP_TYPE_MISMATCH",
+    category: "render_ui",
+    description: "A render-ui pattern prop has a value that is not one of its allowed values"
+  },
+  {
+    code: "ORB_RUI_RENDERABLE_IN_GENERIC_FIELD",
+    category: "render_ui",
+    description: "A render-ui pattern literal is passed to a field not typed node, hiding renderable content from render-ui checks"
+  },
+  {
+    code: "ORB_SET_COLUMN_WITHOUT_ROW",
+    category: "entity_mutation",
+    description: "A set writes an entity column with no row in scope and no persist create or update that could land it"
+  },
+  {
+    code: "ORB_SHARED_ENTITY_FIELD_CONFLICT",
+    category: "entity_mutation",
+    description: "A field of a shared entity is written by more than one trait"
+  },
+  {
+    code: "ORB_SHARED_ENTITY_RENDER_AUTHORITY",
+    category: "entity_mutation",
+    description: "A shared entity is render-ui-read by more than one trait, but only one render authority is allowed per entity and slot"
+  },
+  {
+    code: "ORB_SLOT_CONTENTION",
+    category: "slot",
+    description: "Multiple traits on a page render into the same slot"
+  },
+  {
+    code: "ORB_SLOT_CONTENTION_RUNTIME",
+    category: "slot",
+    description: "Several traits render to the same slot in the same state, so they contend for it"
+  },
+  {
+    code: "ORB_SLOT_CONTENTION_TICK",
+    category: "slot",
+    description: "Several traits on a page render into the same slot from ticks, so their output contends"
+  },
+  {
+    code: "ORB_SLOT_INVALID_NESTING",
+    category: "slot",
+    description: "A slot is nested in an invalid way"
+  },
+  {
+    code: "ORB_SLOT_MAIN_NOT_COVERED",
+    category: "slot",
+    description: "No trait on a page renders anything into the main slot"
+  },
+  {
+    code: "ORB_STORE_DRIVER_CONTRACT",
+    category: "store",
+    description: "A store driver has no trait handling one or more verbs required by the row-store driver contract"
+  },
+  {
+    code: "ORB_STORE_DRIVER_NOT_CONDITIONAL",
+    category: "store",
+    description: "A conditional persist op is bound to a store driver that cannot execute conditional writes"
+  },
+  {
+    code: "ORB_STORE_ON_NON_PERSISTENT",
+    category: "store",
+    description: "An entity binds a store but its rows live in no store"
+  },
+  {
+    code: "ORB_STORE_UNKNOWN_ORBITAL",
+    category: "store",
+    description: "A store binding names an orbital that is not part of the program"
+  },
+  {
+    code: "ORB_STORE_VERB_OUTSIDE_SEAM",
+    category: "store",
+    description: "A trait emits a row-store verb directly, but a store driver may be asked only by the store seam"
+  },
+  {
+    code: "ORB_S_ACCESS_POLICY_INVALID_BINDING",
+    category: "schema",
+    description: "An access directive uses a binding other than the ones legal there"
+  },
+  {
+    code: "ORB_S_ACCESS_POLICY_REQUIRES_IDENTITY",
+    category: "schema",
+    description: "An access directive reads @user but the program declares no identity entity"
+  },
+  {
+    code: "ORB_S_ACCESS_POLICY_UNKNOWN_ENTITY_FIELD",
+    category: "schema",
+    description: "An access policy references a name that is not a field of its entity, so it resolves to null and denies everyone"
+  },
+  {
+    code: "ORB_S_COLLECTION_POLICY_CONFLICT",
+    category: "schema",
+    description: "Entities bound to the same collection declare different access directives"
+  },
+  {
+    code: "ORB_S_EMPTY_VERSION",
+    category: "schema",
+    description: "The schema version is empty"
+  },
+  {
+    code: "ORB_S_EXPECTATION_FIELD_UNDECLARED",
+    category: "schema",
+    description: "An effect persists a field that the orbital's expects entity shape does not declare"
+  },
+  {
+    code: "ORB_S_EXPECTATION_PROVIDER_MISMATCH",
+    category: "schema",
+    description: "An expectation requires a field to be marked as a key but the providing entity declares it without that mark"
+  },
+  {
+    code: "ORB_S_EXPECTATION_UNSATISFIED",
+    category: "schema",
+    description: "An orbital expects an entity, trait, event, or config default that nothing in the program provides"
+  },
+  {
+    code: "ORB_S_EXPECTED_FIELD_NOT_PROVIDED",
+    category: "schema",
+    description: "A rebound entity does not provide a field that the trait expects it to have"
+  },
+  {
+    code: "ORB_S_EXPECTED_FIELD_TYPE_MISMATCH",
+    category: "schema",
+    description: "The provider has the expected field or knob but with an incompatible type"
+  },
+  {
+    code: "ORB_S_IDENTITY_NOT_UNIQUE",
+    category: "schema",
+    description: "More than one entity is tagged identity, making every @user field reference ambiguous"
+  },
+  {
+    code: "ORB_S_INVARIANT_UNPROVED",
+    category: "spec",
+    description: "A spec proposition the prover cannot decide, so the program is not shown to keep it"
+  },
+  {
+    code: "ORB_S_INVARIANT_VIOLATED",
+    category: "spec",
+    description: "A spec proposition (invariant, holds, ensures) is broken by a write, with a counterexample the evaluator confirms"
+  },
+  {
+    code: "ORB_S_MISSING_NAME",
+    category: "schema",
+    description: "The schema does not declare a name"
+  },
+  {
+    code: "ORB_S_NO_ORBITALS",
+    category: "schema",
+    description: "The schema declares no orbitals"
+  },
+  {
+    code: "ORB_S_OWNER_FIELD_NOT_IDENTITY_TYPED",
+    category: "schema",
+    description: "An access directive compares a field to @user.id but the field is not a relation to the identity entity"
+  },
+  {
+    code: "ORB_S_ROLE_LITERAL_NOT_MEMBER",
+    category: "schema",
+    description: "A literal compared against an @user field with a closed vocabulary is not a member of that vocabulary, so the branch can never be taken"
+  },
+  {
+    code: "ORB_S_SHARED_WITHOUT_PERSISTENCE_MODE",
+    category: "schema",
+    description: "A shared entity declares no persistence mode, and none may be inferred"
+  },
+  {
+    code: "ORB_S_UNKNOWN_IDENTITY_FIELD",
+    category: "schema",
+    description: "A read of a field of the signed-in user names a field the declared identity entity does not have"
+  },
+  {
+    code: "ORB_TAB_EFFECT_ON_SERVER",
+    category: "tab",
+    description: "A browser tab effect is used in a transition that runs on the server, which holds no tabs"
+  },
+  {
+    code: "ORB_TAB_REQUEST_INVALID",
+    category: "browser",
+    description: "A browser/tab request is not an object of the operation's closed keys or has refused literal values"
+  },
+  {
+    code: "ORB_THEME_PIN_CONTRADICTS_APP",
+    category: "theme",
+    description: "An orbital pins a theme that differs from the theme the app declares at app level"
+  },
+  {
+    code: "ORB_THEME_UNDECLARED",
+    category: "theme",
+    description: "A frame is shown in a literal theme that the program does not declare, so no stylesheet ships for it"
+  },
+  {
+    code: "ORB_TICK_ASYNC_EFFECT",
+    category: "tick",
+    description: "A tick calls a server-async operator, which ticks cannot run"
+  },
+  {
+    code: "ORB_TICK_REQUIRES_RUNTIME",
+    category: "trait",
+    description: "A non-cron tick mutates a persistent entity, which should usually be runtime"
+  },
+  {
+    code: "ORB_T_CLIENT_TICK_NOT_LOCAL",
+    category: "trait",
+    description: "A trait writes a frame entity ticked on the client but declares no dispatch mode, so a server step overwrites the live frame"
+  },
+  {
+    code: "ORB_T_CLIENT_TICK_SERVER_EFFECT",
+    category: "trait",
+    description: "A tick that runs in the browser has effects that reach the server, and nothing replays a tick there"
+  },
+  {
+    code: "ORB_T_CONFIG_MISSING_REQUIRED_KEY",
+    category: "trait",
+    description: "A trait reference does not supply a config knob that the referenced trait declares as required"
+  },
+  {
+    code: "ORB_T_CONFIG_OBJECT_ARRAY_FORBIDDEN",
+    category: "trait",
+    description: "A config field uses a banned bare object or array type instead of a named struct alias"
+  },
+  {
+    code: "ORB_T_CONFIG_TIER_INVALID",
+    category: "trait",
+    description: "A config field declares a tier value outside domain, policy, infra, presentation and internal"
+  },
+  {
+    code: "ORB_T_CONFIG_UNKNOWN_CALL_SITE_KEY",
+    category: "trait",
+    description: "A call-site config key matches no config knob declared on the referenced trait"
+  },
+  {
+    code: "ORB_T_DUPLICATE_NAME",
+    category: "trait",
+    description: "The same trait name is defined in more than one orbital"
+  },
+  {
+    code: "ORB_T_DUPLICATE_STATE",
+    category: "trait",
+    description: "A trait declares the same state name more than once"
+  },
+  {
+    code: "ORB_T_DUPLICATE_TRANSITION",
+    category: "trait",
+    description: "Two transitions share the same source state and event without guards"
+  },
+  {
+    code: "ORB_T_EMPTY_EVENT_NAME",
+    category: "trait",
+    description: "An event name is empty"
+  },
+  {
+    code: "ORB_T_ENDPOINT_TRAIT_RENDERS",
+    category: "trait",
+    description: "A trait mounted only on protocol endpoints renders UI, which endpoints cannot show"
+  },
+  {
+    code: "ORB_T_ENTITY_NAME_SHADOWS_TRAIT_UNION",
+    category: "trait",
+    description: "An entity name collides with a trait's generated state union type"
+  },
+  {
+    code: "ORB_T_ENTITY_NOT_REBINDABLE",
+    category: "trait",
+    description: "A trait is bound to an entity it cannot be rebound to"
+  },
+  {
+    code: "ORB_T_EVENT_RENAME_UNKNOWN_KEY",
+    category: "trait",
+    description: "An events rename key names no event declared by the referenced trait"
+  },
+  {
+    code: "ORB_T_EVT_EXTERNAL_MISSING_PAYLOAD",
+    category: "trait",
+    description: "An external event does not declare a typed payload"
+  },
+  {
+    code: "ORB_T_EVT_INVALID_NAME",
+    category: "trait",
+    description: "An event name is not a valid UPPER_SNAKE_CASE identifier"
+  },
+  {
+    code: "ORB_T_EVT_UNDECLARED",
+    category: "trait",
+    description: "An event is emitted but not declared in the trait's emits array"
+  },
+  {
+    code: "ORB_T_EXTERNAL_INPUT_NOT_RESTING",
+    category: "trait",
+    description: "An external input is not accepted from the trait's initial state"
+  },
+  {
+    code: "ORB_T_GENERIC_TYPE_DEPRECATED",
+    category: "trait",
+    description: "A declaration uses a generic type such as bare json, object without properties, or any, which the language no longer allows"
+  },
+  {
+    code: "ORB_T_INIT_MISSING_FETCH",
+    category: "trait",
+    description: "No trait fetches a persistent entity on INIT, so interaction traits read data nothing loads"
+  },
+  {
+    code: "ORB_T_INVALID_EVENT_DEFAULT",
+    category: "trait",
+    description: "A config field typed event holds a value that is not a valid event name or member of the trait's event set"
+  },
+  {
+    code: "ORB_T_INVALID_FORMAT",
+    category: "trait",
+    description: "A trait reference has neither a ref nor a name property"
+  },
+  {
+    code: "ORB_T_INVALID_PATTERN_DEFAULT",
+    category: "trait",
+    description: "A pattern-typed config knob has a default that is not a known pattern type"
+  },
+  {
+    code: "ORB_T_INVALID_SLOT_DEFAULT",
+    category: "trait",
+    description: "A slot-typed config field has a default that is not a valid slot"
+  },
+  {
+    code: "ORB_T_INVALID_TRANSITION",
+    category: "trait",
+    description: "A transition references a source or target state that does not exist"
+  },
+  {
+    code: "ORB_T_LOCAL_ON_NON_SHARED_PERSISTENT",
+    category: "trait",
+    description: "A client-dispatch trait is linked to an entity that is neither shared nor client-resident, hiding server-gated writes behind optimism"
+  },
+  {
+    code: "ORB_T_LOCAL_TRAIT_TOUCHES_SERVER",
+    category: "trait",
+    description: "A client trait transition guards on or touches server-only state"
+  },
+  {
+    code: "ORB_T_MISSING_INIT_TRANSITION",
+    category: "trait",
+    description: "A route trait has no INIT transition on its initial state"
+  },
+  {
+    code: "ORB_T_MULTIPLE_INITIAL_STATES",
+    category: "trait",
+    description: "A trait state machine declares more than one initial state"
+  },
+  {
+    code: "ORB_T_NO_INITIAL_STATE",
+    category: "trait",
+    description: "A state machine declares no states and so has no initial state"
+  },
+  {
+    code: "ORB_T_REBIND_MISSING_FIELDS",
+    category: "trait",
+    description: "A trait is rebound to an entity that lacks fields the trait requires"
+  },
+  {
+    code: "ORB_T_REBIND_TARGET_UNRESOLVED",
+    category: "trait",
+    description: "A trait rebind target cannot be resolved"
+  },
+  {
+    code: "ORB_T_SECRET_DEFAULT_NOT_STRING",
+    category: "trait",
+    description: "A config field typed secret does not default to a string credential reference"
+  },
+  {
+    code: "ORB_T_STATE_UNREACHABLE",
+    category: "trait",
+    description: "A state is unreachable from the initial state through any transition path"
+  },
+  {
+    code: "ORB_T_TRAIT_ON_ROUTE_AND_ENDPOINT",
+    category: "trait",
+    description: "A trait is mounted on both a route page and a protocol endpoint"
+  },
+  {
+    code: "ORB_T_TRAIT_UNMOUNTED",
+    category: "trait",
+    description: "A trait owns a state machine but is listed on no page and reached by no embed"
+  },
+  {
+    code: "ORB_T_UNDEFINED_EVENT",
+    category: "trait",
+    description: "A transition uses an event that is not defined in the trait's events array"
+  },
+  {
+    code: "ORB_T_UNDEFINED_TRAIT",
+    category: "trait",
+    description: "A trait reference does not give a trait name"
+  },
+  {
+    code: "ORB_T_UNRESOLVED_TYPE_PARAM",
+    category: "trait",
+    description: "A declaration uses a type variable that no trait parameter binds"
+  },
+  {
+    code: "ORB_UI_ICON_EMPTY",
+    category: "icon",
+    description: "An icon name is empty"
+  },
+  {
+    code: "ORB_UI_ICON_INVALID_FORMAT",
+    category: "icon",
+    description: "An icon name has an invalid format"
+  },
+  {
+    code: "ORB_UI_ICON_NOT_FOUND",
+    category: "icon",
+    description: "An icon name does not exist in the icon set"
+  },
+  {
+    code: "ORB_U_CONFIG_UNKNOWN_KEY",
+    category: "uses",
+    description: "A uses config override names a knob the imported behavior app-level config never declared"
+  },
+  {
+    code: "ORB_W_LOOP_INVARIANT_PARSE",
+    category: "lint",
+    description: "A parse inside a lambda re-parses the same value for every element and should be bound once outside"
+  },
+  {
+    code: "ORB_X_CIRCULAR_DEPENDENCY",
+    category: "cross",
+    description: "Traits form a circular event dependency"
+  },
+  {
+    code: "ORB_X_CROSS_EMITTER_DECLARED_PAYLOAD_MISMATCH",
+    category: "cross",
+    description: "An event declared by several emitters has conflicting payload fields across them"
+  },
+  {
+    code: "ORB_X_DUPLICATE_ENTITY",
+    category: "cross",
+    description: "The same entity name is defined in more than one orbital"
+  },
+  {
+    code: "ORB_X_DUPLICATE_TRAIT_ID",
+    category: "cross",
+    description: "Two or more traits carry the same trait id, so listens match each other's emits"
+  },
+  {
+    code: "ORB_X_ENUM_VALUE_NOT_MEMBER",
+    category: "cross",
+    description: "A set effect assigns a string literal that is not a declared member of the target field's enum"
+  },
+  {
+    code: "ORB_X_FILTER_FIELD_NEVER_WRITTEN",
+    category: "cross",
+    description: "A fetch filters on a field that no persist create or update of that entity supplies, so it always returns empty"
+  },
+  {
+    code: "ORB_X_LISTEN_PER_ENTITY",
+    category: "trait_event",
+    description: "A trait that listens per a key does not link a [runtime] entity declaring an id : string field"
+  },
+  {
+    code: "ORB_X_LISTEN_PER_ROUTED_PAGE",
+    category: "trait_event",
+    description: "A trait that listens per a key is placed on a route page"
+  },
+  {
+    code: "ORB_X_LISTEN_SOURCE_NEVER_PRODUCES",
+    category: "cross",
+    description: "A listens route names a source whose emits contract never produces the listened event"
+  },
+  {
+    code: "ORB_X_LISTEN_SOURCE_UNRESOLVED",
+    category: "cross",
+    description: "A listen entry references a source trait event that the source does not declare"
+  },
+  {
+    code: "ORB_X_LISTEN_TRIGGER_UNMATCHED",
+    category: "cross",
+    description: "A listens entry triggers an event that no transition in the same trait reacts to"
+  },
+  {
+    code: "ORB_X_LLM_WIRE_UNROUTED",
+    category: "cross",
+    description: "A composed std-llm trait can emit a wire event that no trait in the program listens to"
+  },
+  {
+    code: "ORB_X_MISSING_ORBITAL_NAME",
+    category: "cross",
+    description: "An orbital does not declare a name"
+  },
+  {
+    code: "ORB_X_ORPHAN_LISTENER",
+    category: "cross",
+    description: "A trait listens for an event that no trait emits"
+  },
+  {
+    code: "ORB_X_PARALLEL_LAMBDA_IMPURE",
+    category: "parallel",
+    description: "The lambda of array/pmap or array/preduce is not a literal fn or is not provably pure"
+  },
+  {
+    code: "ORB_X_PAYLOAD_FIELD_NAME",
+    category: "cross",
+    description: "A payload field name is not a valid TypeScript identifier"
+  },
+  {
+    code: "ORB_X_PAYLOAD_MISMATCH",
+    category: "cross",
+    description: "An external emit is missing a payload field required by the event's declaration"
+  },
+  {
+    code: "ORB_X_RENDER_UI_EVENT_LITERAL_STALE",
+    category: "cross",
+    description: "A render-ui prop references an event literal that no longer matches a declared event"
+  },
+  {
+    code: "ORB_X_ROW_LITERAL_FIELD_TYPE_MISMATCH",
+    category: "effect",
+    description: "A record literal written into an entity carries a value whose type the declared field does not admit."
+  },
+  {
+    code: "ORB_X_ROW_LITERAL_MISSING_REQUIRED",
+    category: "effect",
+    description: "A `persist create` data literal omits a column the entity requires (no default, not framework-stamped)."
+  },
+  {
+    code: "ORB_X_ROW_LITERAL_UNKNOWN_FIELD",
+    category: "effect",
+    description: "A record literal written into an entity (a `persist` data literal, or a `set` into a relation field) names a key the entity does not declare."
+  },
+  {
+    code: "ORB_X_UNKNOWN_THEME",
+    category: "cross",
+    description: "A theme reference is neither a built-in theme key nor an orbital-declared inline theme"
+  },
+  {
+    code: "ORB_X_UNRESOLVED_RELATION_TARGET",
+    category: "cross",
+    description: "A relation field points at an entity that is not declared in the schema"
+  },
+  {
+    code: "ORB_X_UNTYPED_ARRAY",
+    category: "cross",
+    description: "An array field declares no element type"
+  },
+  {
+    code: "ORB_X_UNUSED_EMISSION",
+    category: "cross",
+    description: "A trait emits an event that no trait listens for"
+  },
+  {
+    code: "SEXPR_INVALID_BINDING",
+    category: "sexpr",
+    description: "An s-expression contains an invalid binding"
+  },
+  {
+    code: "SEXPR_INVALID_OPERATOR",
+    category: "sexpr",
+    description: "An S-expression uses an operator that is not in the operator registry"
+  },
+  {
+    code: "SEXPR_UNKNOWN_ENTITY",
+    category: "sexpr",
+    description: "An entity named in a binding may not exist in the program"
+  },
+  {
+    code: "inbound-hook-duplicate",
+    category: "lint",
+    description: "Two cli hooks declare the same inbound name"
+  },
+  {
+    code: "shared-type-drift",
+    category: "lint",
+    description: "A type shared between behaviors has drifted from its canonical declaration"
+  },
+  {
+    code: "unread",
+    category: "lint",
+    description: "The file the rule reads could not be read or listed"
+  }
+];
+
+// src/types/validation.ts
+var validationCodes = validation_codes_default;
+var ORBITAL_PATH_PREFIX = /^orbitals\[(\d+)(?: \([^\]]*\))?\]/;
+function orbitalIndexOfValidationPath(path) {
+  if (Array.isArray(path)) {
+    if (path[0] === "orbitals") return typeof path[1] === "number" ? path[1] : null;
+    return typeof path[0] === "string" ? orbitalIndexOfValidationPath(path[0]) : null;
+  }
+  const m = typeof path === "string" ? ORBITAL_PATH_PREFIX.exec(path) : null;
+  return m ? Number(m[1]) : null;
+}
+var KNOWN_VALIDATION_ERROR_CODES = Object.fromEntries(
+  validationCodes.map((entry) => [entry.code, entry.code])
+);
+function isKnownValidationErrorCode(code) {
+  return code in KNOWN_VALIDATION_ERROR_CODES;
+}
+
+// src/types/living.ts
+function widenTier(tier) {
+  return tier;
+}
+var ARIA_LIVE = ["off", "polite", "assertive"];
+var ARIA_CURRENT = ["page", "step", "location", "date", "time", "true", "false"];
+var ARIA_PRESSED = ["true", "false", "mixed"];
+var TEXT_DIRECTIONS = ["ltr", "rtl", "auto"];
+var TAB_INDEX_VALUES = [-1, 0];
+var ARIA_ROLES = [
+  "alert",
+  "alertdialog",
+  "application",
+  "article",
+  "banner",
+  "blockquote",
+  "button",
+  "caption",
+  "cell",
+  "checkbox",
+  "code",
+  "columnheader",
+  "combobox",
+  "complementary",
+  "contentinfo",
+  "definition",
+  "deletion",
+  "dialog",
+  "document",
+  "emphasis",
+  "feed",
+  "figure",
+  "form",
+  "generic",
+  "grid",
+  "gridcell",
+  "group",
+  "heading",
+  "img",
+  "insertion",
+  "link",
+  "list",
+  "listbox",
+  "listitem",
+  "log",
+  "main",
+  "marquee",
+  "math",
+  "menu",
+  "menubar",
+  "menuitem",
+  "menuitemcheckbox",
+  "menuitemradio",
+  "meter",
+  "navigation",
+  "none",
+  "note",
+  "option",
+  "paragraph",
+  "presentation",
+  "progressbar",
+  "radio",
+  "radiogroup",
+  "region",
+  "row",
+  "rowgroup",
+  "rowheader",
+  "scrollbar",
+  "search",
+  "searchbox",
+  "separator",
+  "slider",
+  "spinbutton",
+  "status",
+  "strong",
+  "subscript",
+  "superscript",
+  "switch",
+  "tab",
+  "table",
+  "tablist",
+  "tabpanel",
+  "term",
+  "textbox",
+  "time",
+  "timer",
+  "toolbar",
+  "tooltip",
+  "tree",
+  "treegrid",
+  "treeitem"
+];
+var AriaRoleSchema = z.enum(ARIA_ROLES);
+var ARIA_ROLE_SET = new Set(ARIA_ROLES);
+function isAriaRole(value) {
+  return ARIA_ROLE_SET.has(value);
+}
+var A11Y_ATTRIBUTES = {
+  "aria-label": { types: ["string"], description: "Accessible name read by screen readers when the visible text is missing or not descriptive (e.g. an icon-only control)." },
+  "aria-labelledby": { types: ["string"], description: "Id of the element whose text names this one." },
+  "aria-describedby": { types: ["string"], description: "Id of the element whose text describes this one (help text, error)." },
+  "aria-live": { types: ["string"], enumValues: ARIA_LIVE, description: "Announce changes to this region: polite waits for a pause, assertive interrupts." },
+  "aria-current": { types: ["string"], enumValues: ARIA_CURRENT, description: "Marks the current item in a set: the current page, step, location, date or time." },
+  "aria-pressed": { types: ["string"], enumValues: ARIA_PRESSED, description: "Toggle-button state." },
+  "aria-expanded": { types: ["boolean"], description: "Whether the element it controls is expanded." },
+  "aria-selected": { types: ["boolean"], description: "Whether this item is selected (tabs, options, grid cells)." },
+  "aria-hidden": { types: ["boolean"], description: "Hide from assistive technology (decorative content only)." },
+  "aria-busy": { types: ["boolean"], description: "This region is updating; assistive technology waits before announcing it." },
+  role: { types: ["string"], enumValues: ARIA_ROLES, description: "WAI-ARIA role when the element's native semantics don't describe it." },
+  lang: { types: ["string"], description: "Language of this element's content (BCP 47, e.g. ar, sl, en)." },
+  dir: { types: ["string"], enumValues: TEXT_DIRECTIONS, description: "Text direction of this element's content." },
+  tabIndex: { types: ["number"], numericEnumValues: TAB_INDEX_VALUES, description: "0 puts the element in the Tab order; -1 makes it focusable only programmatically." }
+};
+var ACCESSIBLE_NAME_ATTRIBUTES = ["aria-label", "aria-labelledby"];
+
+// src/types/surface.ts
+var SURFACE_MODES = ["auto", "none"];
+var DIAGRAM_TONES = [
+  "ink",
+  "label",
+  "guide",
+  "axis",
+  "grid",
+  "highlight",
+  "fill",
+  "series-1",
+  "series-2",
+  "series-3",
+  "series-4",
+  "series-5",
+  "series-6",
+  "series-7",
+  "series-8",
+  "primary",
+  "accent",
+  "success",
+  "warning",
+  "error",
+  "info",
+  "muted"
+];
+var DiagramToneSchema = z.enum(DIAGRAM_TONES);
+var DIAGRAM_TONE_COLOR_KEYS = {
+  ink: "diagram-ink",
+  label: "diagram-label",
+  guide: "diagram-guide",
+  axis: "diagram-axis",
+  grid: "diagram-grid",
+  highlight: "diagram-highlight",
+  fill: "diagram-fill",
+  "series-1": "series-1",
+  "series-2": "series-2",
+  "series-3": "series-3",
+  "series-4": "series-4",
+  "series-5": "series-5",
+  "series-6": "series-6",
+  "series-7": "series-7",
+  "series-8": "series-8",
+  primary: "primary",
+  accent: "accent",
+  success: "success",
+  warning: "warning",
+  error: "error",
+  info: "info",
+  muted: "muted-foreground"
+};
+var DIAGRAM_STROKE_WEIGHTS = ["thin", "normal", "bold"];
+var DiagramStrokeWeightSchema = z.enum(DIAGRAM_STROKE_WEIGHTS);
+var DIAGRAM_TEXT_SIZES = ["xs", "sm", "base", "lg", "xl", "2xl"];
+var DiagramTextSizeSchema = z.enum(DIAGRAM_TEXT_SIZES);
+var DIAGRAM_TEXT_CASES = ["theme", "verbatim"];
+var DiagramTextCaseSchema = z.enum(DIAGRAM_TEXT_CASES);
+var EVAL_TIERS = ["none", "organism", "subset", "compose", "substrate", "free"];
+function validPattern(p) {
+  try {
+    new RegExp(p.pattern, p.flags);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var EvalPatternSchema = z.object({ pattern: z.string(), flags: z.string().optional() }).strict().refine(validPattern, { message: "pattern is not a valid regular expression" });
+var EvalPredicateSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("entity") }).strict(),
+  z.object({ kind: z.literal("field"), required: z.boolean().optional() }).strict(),
+  z.object({ kind: z.literal("enumValue"), value: EvalPatternSchema }).strict(),
+  z.object({ kind: z.literal("roleGated") }).strict(),
+  z.object({ kind: z.literal("ownerScoped"), by: EvalPatternSchema.optional() }).strict(),
+  z.object({ kind: z.literal("feeds"), with: EvalPatternSchema }).strict(),
+  z.object({ kind: z.literal("notifies") }).strict(),
+  z.object({ kind: z.literal("input") }).strict(),
+  z.object({ kind: z.literal("agent") }).strict(),
+  z.object({ kind: z.literal("route"), path: z.string() }).strict(),
+  z.object({ kind: z.literal("rendered"), route: z.string().optional(), on: EvalPatternSchema.optional() }).strict(),
+  z.object({ kind: z.literal("absentText"), words: z.array(z.string()) }).strict(),
+  z.object({ kind: z.literal("absentEntity") }).strict(),
+  z.object({ kind: z.literal("orbital"), absent: z.boolean().optional() }).strict(),
+  z.object({ kind: z.literal("knob"), key: z.string().min(1), value: JsonValueSchema }).strict()
+]);
+var EvalCheckSchema = z.object({
+  id: z.string().min(1),
+  introducedTurn: z.number().int().min(0),
+  nouns: EvalPatternSchema,
+  require: z.array(EvalPredicateSchema),
+  frameRoutes: z.array(z.string()).optional(),
+  coversDeclines: z.array(z.string()).optional()
+}).strict();
+var EvalSpecSchema = z.object({
+  id: z.string().min(1),
+  class: z.enum(["plain", "specific", "complex"]),
+  description: z.string().optional(),
+  turns: z.tuple([z.string()]).rest(z.string()),
+  checks: z.array(EvalCheckSchema),
+  expect: z.object({
+    tiers: z.array(z.enum(EVAL_TIERS)).optional(),
+    adopts: z.array(z.string()).optional(),
+    orbitals: z.array(z.string()).optional(),
+    validates: z.boolean().optional()
+  }).strict().optional(),
+  forbidSources: z.array(z.string()).optional()
+}).strict().superRefine((spec, ctx) => {
+  for (const [i, check] of spec.checks.entries()) {
+    if (check.introducedTurn >= spec.turns.length) {
+      ctx.addIssue({ code: "custom", path: ["checks", i, "introducedTurn"], message: `introducedTurn ${check.introducedTurn} is past the spec's ${spec.turns.length} turns` });
+    }
+  }
+});
+function parseEvalSpec(input) {
+  const parsed = EvalSpecSchema.safeParse(input);
+  if (parsed.success) return parsed.data;
+  throw new Error(`invalid eval spec: ${parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ")}`);
+}
+function evalPatternMatches(p, text) {
+  return new RegExp(p.pattern, p.flags).test(text);
+}
+
+// src/types/tab-port.ts
+var TabHostFailure = class extends Error {
+  constructor(kind, message) {
+    super(message);
+    this.kind = kind;
+    this.name = "TabHostFailure";
+  }
+};
+var ClientThemeSchema = z.object({
+  name: z.string().min(1),
+  displayName: z.string(),
+  hasLightMode: z.boolean(),
+  hasDarkMode: z.boolean()
+}).strict();
+var ClientManifestSchema = z.object({
+  locale: z.string().min(1),
+  direction: z.enum(["ltr", "rtl"]),
+  themes: z.array(ClientThemeSchema),
+  defaultTheme: z.string().min(1).nullable(),
+  defaultMode: z.enum(["light", "dark"])
+}).strict();
+function parseClientManifest(value) {
+  return ClientManifestSchema.parse(value);
+}
+var PayloadSlotSchema = z.object({
+  name: z.string(),
+  type: z.string(),
+  required: z.boolean(),
+  values: z.array(z.string()).optional(),
+  entity: z.string().optional()
+});
+var MachineRowSchema = z.object({
+  orbital: z.string(),
+  trait: z.string(),
+  from: z.string(),
+  event: z.string(),
+  to: z.string(),
+  guarded: z.boolean(),
+  payload: z.array(PayloadSlotSchema)
+});
+var EvalPathSchema = z.array(z.union([z.number(), z.string()]));
+var EvalStepWireSchema = z.object({
+  kind: z.enum(["enter", "exit", "iter", "skip"]),
+  path: EvalPathSchema,
+  value: JsonValueSchema.optional(),
+  error: z.string().optional()
+});
+var PlayedEffectSchema = z.object({
+  type: z.string(),
+  args: z.array(JsonValueSchema),
+  status: z.enum(["executed", "failed", "skipped"]),
+  error: z.string().optional(),
+  routed: z.boolean()
+});
+var PropositionBindingsSchema = z.object({
+  entity: JsonValueSchema,
+  fromEntity: JsonValueSchema,
+  payload: JsonValueSchema
+});
+var PlayedEnsuresSchema = z.object({
+  proposition: JsonValueSchema,
+  verdict: z.enum(["held", "broken", "inconclusive"]),
+  reason: z.string().optional(),
+  counterexample: PropositionBindingsSchema.optional()
+});
+var PlayedEmitSchema = z.object({
+  type: z.string(),
+  payload: EventPayloadSchema.optional(),
+  timestamp: z.number()
+});
+var PlayedGuardSchema = z.object({
+  arm: z.number(),
+  guard: JsonValueSchema,
+  passed: z.boolean(),
+  trace: z.array(EvalStepWireSchema),
+  error: z.string().optional()
+});
+var EntityBindingSchema = z.object({
+  kind: z.enum(["none", "absent", "malformed", "inline", "named", "payload-unresolved", "context-unresolved"]),
+  entity: z.string(),
+  rows: z.number(),
+  readGated: z.boolean()
+});
+var TraitRefSchema = z.object({
+  name: z.string(),
+  resolved: z.boolean(),
+  overlayOnly: z.boolean()
+});
+var RenderedNodeSchema = z.object({
+  pattern: z.string(),
+  dynamic: z.boolean(),
+  supported: z.boolean(),
+  stub: z.boolean(),
+  binding: EntityBindingSchema,
+  traitRefs: z.array(TraitRefSchema)
+});
+var RenderedSlotSchema = z.object({
+  slot: z.string(),
+  sourceTrait: z.string(),
+  ownerEntity: z.string(),
+  nodes: z.array(RenderedNodeSchema),
+  props: JsonValueSchema.optional(),
+  fault: z.object({ code: z.enum(["no-matching-transition", "guard-rejected", "no-dispatchable-traits", "not-an-external-input", "inbound-only-event", "effect-failed", "locale-not-declared", "client-circuit-state-refused", "repaint-failed"]), error: z.string() }).optional()
+});
+var PlayedStateSchema = z.object({ before: z.string().nullable(), after: z.string().nullable() });
+var PendingAskSchema = z.object({
+  trait: z.string(),
+  operator: z.string(),
+  args: z.array(JsonValueSchema),
+  key: z.string()
+});
+var PlayedOutcomeSchema = z.object({
+  orbital: z.string(),
+  trait: z.string(),
+  event: z.string(),
+  from: z.string(),
+  to: z.string(),
+  arm: z.number().optional(),
+  fired: z.boolean(),
+  effects: z.array(PlayedEffectSchema),
+  emitted: z.array(PlayedEmitSchema)
+});
+var JsonRecordSchema = z.record(z.string(), JsonValueSchema);
+var PlayedResultSchema = z.object({
+  trait: z.string(),
+  event: z.string(),
+  transitionFired: z.boolean(),
+  guard: z.enum(["pass", "fail", "none"]),
+  firedArm: z.number().optional(),
+  state: PlayedStateSchema,
+  effects: z.array(PlayedEffectSchema),
+  emitted: z.array(PlayedEmitSchema),
+  guards: z.array(PlayedGuardSchema),
+  ensures: z.array(PlayedEnsuresSchema),
+  rendered: z.array(RenderedSlotSchema).optional(),
+  failure: z.string().optional(),
+  entityAfter: EventPayloadSchema.nullable(),
+  pendingAsks: z.array(PendingAskSchema),
+  outcomes: z.array(PlayedOutcomeSchema)
+});
+var PlayedStepSchema = z.object({
+  orbital: z.string(),
+  trait: z.string(),
+  from: z.string(),
+  event: z.string(),
+  payload: EventPayloadSchema,
+  result: PlayedResultSchema,
+  entity: JsonRecordSchema.optional(),
+  config: JsonRecordSchema.optional(),
+  now: z.number().optional(),
+  settleMs: z.number().optional(),
+  identity: z.object({ subject: z.string(), claims: JsonRecordSchema }).optional(),
+  credentials: z.record(z.string(), z.string()).optional()
+});
+var ProgramSourceLocationSchema = z.object({
+  path: z.string(),
+  line: z.number().int().positive(),
+  column: z.number().int().positive(),
+  length: z.number().int().nonnegative(),
+  endLine: z.number().int().positive(),
+  endColumn: z.number().int().positive(),
+  exact: z.boolean(),
+  scopeEndLine: z.number().int().positive().optional(),
+  scopeEndColumn: z.number().int().positive().optional(),
+  scopeLength: z.number().int().nonnegative().optional()
+});
+var ProgramSourceAnchorSchema = ProgramSourceLocationSchema.extend({
+  pointer: z.string(),
+  orbitalId: z.string().nullable(),
+  traitId: z.string().nullable(),
+  originTraitId: z.string()
+});
+var ProgramInspectionSchema = z.object({
+  program: OrbitalSchemaSchema,
+  authoredProgram: OrbitalSchemaSchema,
+  definitions: z.array(z.object({
+    traitId: z.string(),
+    definitionFingerprint: z.string(),
+    sourceDeclaration: SourceDeclarationMetadataSchema.extend({ path: z.string().nullable() }).nullable(),
+    sourceCandidates: z.array(z.string())
+  })),
+  composition: z.array(z.object({ traitId: z.string(), kind: z.enum(["trait-declaration", "orbital-reference"]), authoredPointer: z.string(), traitOverrideKey: z.string().nullable(), binding: JsonValueSchema, source: ProgramSourceLocationSchema.nullable() })),
+  sourceMap: z.array(ProgramSourceAnchorSchema),
+  imports: z.array(z.object({ path: z.string(), specifier: z.string(), program: z.string(), authoredProgram: OrbitalSchemaSchema })),
+  lazy: z.array(JsonValueSchema),
+  path: z.string(),
+  version: z.number().int().nonnegative().nullable(),
+  columnEncoding: z.literal("unicode-scalar"),
+  lengthEncoding: z.literal("utf-8-bytes"),
+  lineBase: z.literal(1),
+  columnBase: z.literal(1)
+});
+
+export { A11Y_ATTRIBUTES, ACCESSIBLE_NAME_ATTRIBUTES, ACTION_OVERFLOW_TESTID, ACTION_TESTID_PREFIX, ANONYMOUS_USER, ARIA_CURRENT, ARIA_LIVE, ARIA_PRESSED, ARIA_ROLES, AriaRoleSchema, BINDING_CONTEXT_RULES, BINDING_DOCS, BINDING_ROOTS, BindingSchema, CALL_KINDS, ClientManifestSchema, ClientThemeSchema, DIAGRAM_STROKE_WEIGHTS, DIAGRAM_TEXT_CASES, DIAGRAM_TEXT_SIZES, DIAGRAM_TONES, DIAGRAM_TONE_COLOR_KEYS, DiagramStrokeWeightSchema, DiagramTextCaseSchema, DiagramTextSizeSchema, DiagramToneSchema, DispatchVisits, EMPTY_STATE_MARKER, EVAL_TIERS, EvalSpecSchema, FORM_PATTERN, FULL_WRITE_CAPABILITIES, GESTURE_EVENT_PROPS, KNOWN_VALIDATION_ERROR_CODES, LOADING_STATE_MARKER, LOG_SEVERITIES, MachineRowSchema, NATIVE_ID_PREFIX, NATIVE_ID_SEPARATOR, PATTERN_PROP_TYPE_ERROR_TESTID, PatternTypeSchema, PayloadSlotSchema, PlayedStepSchema, ProgramInspectionSchema, ProgramSourceAnchorSchema, ProgramSourceLocationSchema, QueryCapabilitiesSchema, QueryDeclinedError, RENDER_BINDING_MARKER, ROW_SET_MARKER, RawUserClaimsSchema, RowCommitSchema, RowIdPageSchema, RowPredicateSchema, RowQueryPageSchema, RowQuerySchema, RowSetRefSchema, RowWriteBatchSchema, RowWriteOpSchema, RowWriteOutcomeSchema, SEMANTIC_CHANGE_KINDS, SURFACE_MODES, ServerBatchSummarySchema, ServerEffectResultSchema, TAB_INDEX_VALUES, TEXT_DIRECTIONS, TRAIT_MOUNT_ERROR_TESTID, TabHostFailure, TraitFieldRefSchema, VERIFICATION_DOM_ATTRS, ViewerSchema, WriteCapabilitiesSchema, WriteDeclinedError, actionTestId, actionTestIdMatches, containsEntityBinding, containsPayloadBinding, createLazyService, createTypedEventBus, dispatchVisitKey, evalPatternMatches, findPersonaInRoster, gestureActionTestId, gestureOfActionTestId, getBindingExamples, guardHolds, isAriaRole, isCallRecord, isKnownValidationErrorCode, isPlanSnapshot, isRenderBindingMarker, isRowSetMarker, isSessionHistoryEntry, isStructuredLogEntry, isTraitFieldRef, nativeFieldId, nativeIds, nativePatternId, nativeRowId, nativeSlotId, normalizeUserContext, orbitalIndexOfValidationPath, parseClientManifest, parseEvalSpec, parseFetchOrder, personaFromIdentityRow, resolvePersonaSpec, rowMatchesPredicate, rowSetMarker, runRowWrite, splitNativeIds, toBindingRoot, validateBindingInContext, widenTier };
+//# sourceMappingURL=chunk-GF7KCLNR.js.map
+//# sourceMappingURL=chunk-GF7KCLNR.js.map