@almadar/core 10.129.0 → 11.0.1

package/dist/chunk-PNGFWLHD.js

@@ -0,0 +1,1567 @@
+import { SuggestedGuardSchema, DesignPreferencesSchema, DomainContextSchema, ThemeRefSchema, CustomPatternMapSchema, DesignTokensSchema, ThemeDefinitionSchema } from './chunk-M4S2B5VJ.js';
+import { FieldProjectionSchema, EffectSchema, EntityFieldSchema, TypeVariableSchema, PatternObjectSchema, EntitySchema, EntityPersistenceSchema } from './chunk-FGT5OS2Y.js';
+import { SExprSchema, ExpressionSchema, SExprListSchema } from './chunk-347APWFM.js';
+import { EventIdSchema, PageIdSchema, TraitIdSchema, OrbitalIdSchema, EntityIdSchema, IdentityLedgerSchema } from './chunk-VG7BRFUD.js';
+import { z } from 'zod';
+
+function unionOsGrants(a, b) {
+  const list = (x, y) => [.../* @__PURE__ */ new Set([...x ?? [], ...y ?? []])];
+  const keyed = (x, y, key, items, make) => {
+    const out2 = /* @__PURE__ */ new Map();
+    for (const grant of [...x ?? [], ...y ?? []]) {
+      const seen = out2.get(key(grant));
+      out2.set(key(grant), seen === void 0 ? grant : make(seen, list(items(seen), items(grant))));
+    }
+    return [...out2.values()];
+  };
+  const out = {};
+  const fs = keyed(a?.fs, b?.fs, (g) => g.glob, (g) => g.modes, (g, modes) => ({ ...g, modes }));
+  const net = keyed(a?.net, b?.net, (g) => g.target, (g) => g.kinds, (g, kinds) => ({ ...g, kinds }));
+  if (fs.length > 0) out.fs = fs;
+  if (net.length > 0) out.net = net;
+  const dev = keyed(a?.dev, b?.dev, (g) => g.target, (g) => g.kinds, (g, kinds) => ({ ...g, kinds }));
+  if (dev.length > 0) out.dev = dev;
+  const kv = {};
+  for (const store of [...Object.keys(a?.kv ?? {}), ...Object.keys(b?.kv ?? {})]) {
+    kv[store] = list(a?.kv?.[store], b?.kv?.[store]);
+  }
+  if (Object.keys(kv).length > 0) out.kv = kv;
+  const anchored = {};
+  const distinct = (x, y) => {
+    const out2 = /* @__PURE__ */ new Map();
+    for (const g of [...x ?? [], ...y ?? []]) out2.set(JSON.stringify(g), g);
+    return [...out2.values()];
+  };
+  const anchoredFs = distinct(a?.anchored?.fs, b?.anchored?.fs);
+  const anchoredExec = distinct(a?.anchored?.exec, b?.anchored?.exec);
+  const anchoredNet = distinct(a?.anchored?.net, b?.anchored?.net);
+  if (anchoredFs.length > 0) anchored.fs = anchoredFs;
+  if (anchoredExec.length > 0) anchored.exec = anchoredExec;
+  if (anchoredNet.length > 0) anchored.net = anchoredNet;
+  if (Object.keys(anchored).length > 0) out.anchored = anchored;
+  const exec = list(a?.exec, b?.exec);
+  const env = list(a?.env, b?.env);
+  const stdio = list(a?.stdio, b?.stdio);
+  const sys = list(a?.sys, b?.sys);
+  const desktop = list(a?.desktop, b?.desktop);
+  if (exec.length > 0) out.exec = exec;
+  if (env.length > 0) out.env = env;
+  if (stdio.length > 0) out.stdio = stdio;
+  if (sys.length > 0) out.sys = sys;
+  if (desktop.length > 0) out.desktop = desktop;
+  return out;
+}
+var OsGrantsSchema = z.custom((v) => typeof v === "object" && v !== null && !Array.isArray(v));
+var DeploymentSchema = z.record(z.string(), z.array(z.string()));
+var SKELETON_VARIANTS = ["header", "table", "list", "grid", "detail", "stats", "form", "card", "text"];
+var SkeletonVariantSchema = z.enum(SKELETON_VARIANTS);
+var SkeletonShapeSchema = z.object({
+  variant: SkeletonVariantSchema,
+  rows: z.number().int().positive().optional(),
+  columns: z.number().int().positive().optional(),
+  fields: z.number().int().positive().optional()
+});
+var SkeletonSpecSchema = z.union([SkeletonVariantSchema, z.literal("none"), SkeletonShapeSchema]);
+var SkeletonNodeSchema = z.lazy(
+  () => z.union([z.object({ shape: SkeletonShapeSchema }), z.object({ stack: z.array(SkeletonNodeSchema) })])
+);
+var AwaitRenderSchema = z.object({
+  trait: z.string(),
+  slot: z.string(),
+  skeleton: SkeletonNodeSchema
+});
+var StateSchema = z.object({
+  name: z.string().min(1, "State name is required"),
+  isInitial: z.boolean().optional(),
+  isTerminal: z.boolean().optional(),
+  isFinal: z.boolean().optional(),
+  description: z.string().optional(),
+  onEntry: z.array(z.string()).optional(),
+  onExit: z.array(z.string()).optional(),
+  holds: SExprSchema.optional()
+});
+var PayloadTypeWhenSchema = z.object({
+  knob: z.string().min(1),
+  equals: z.string().min(1),
+  type: z.string().min(1)
+});
+function payloadTypeContainer(type) {
+  if (type === "array") return { kind: "array", element: "" };
+  if (type === "object") return { kind: "object" };
+  if (type.startsWith("Map<") && type.endsWith(">")) {
+    const inner = type.slice(4, -1);
+    const comma = inner.indexOf(",");
+    if (comma > 0 && comma < inner.length - 1) {
+      return { kind: "map", key: inner.slice(0, comma).trim(), value: inner.slice(comma + 1).trim() };
+    }
+  }
+  if (type.length > 2 && type.startsWith("[") && type.endsWith("]")) {
+    return { kind: "array", element: type.slice(1, -1) };
+  }
+  return { kind: "opaque" };
+}
+var payloadFieldShape = {
+  type: z.string().min(1),
+  required: z.boolean().optional(),
+  nullable: z.boolean().optional(),
+  description: z.string().optional(),
+  additionalProperties: z.lazy(() => PayloadFieldDescriptorSchema).optional(),
+  values: z.array(z.string()).optional(),
+  properties: z.lazy(() => z.array(PayloadFieldSchema)).optional(),
+  typeWhen: z.array(PayloadTypeWhenSchema).optional(),
+  entity: z.string().min(1).optional(),
+  projectedFrom: FieldProjectionSchema.optional(),
+  items: z.lazy(() => PayloadFieldDescriptorSchema).optional()
+};
+var PayloadFieldDescriptorSchema = z.object({
+  name: z.string(),
+  ...payloadFieldShape
+});
+var PayloadFieldSchema = z.object({
+  name: z.string().min(1),
+  ...payloadFieldShape
+});
+var InboundVerificationSchema = z.object({
+  header: z.string().min(1),
+  credential: z.string().min(1)
+});
+var InboundDeclarationSchema = z.object({
+  name: z.string().min(1),
+  answers: z.string().min(1),
+  verifies: InboundVerificationSchema.optional()
+});
+var EventSchema = z.object({
+  key: z.string().min(1, "Event key is required"),
+  id: EventIdSchema.optional(),
+  name: z.string().min(1, "Event name is required"),
+  description: z.string().optional(),
+  synonyms: z.string().optional(),
+  tier: z.string().optional(),
+  payloadSchema: z.array(PayloadFieldSchema).optional(),
+  payloadEntity: z.string().optional(),
+  input: z.boolean().optional(),
+  listened: z.boolean().optional(),
+  inbound: InboundDeclarationSchema.optional(),
+  classification: z.enum(["domain", "system"]).optional(),
+  semanticRole: z.string().optional()
+});
+var GuardSchema = z.object({
+  name: z.string().min(1, "Guard name is required"),
+  expression: ExpressionSchema,
+  description: z.string().optional()
+});
+var TransitionSchema = z.object({
+  from: z.string().min(1, "Transition source state is required"),
+  to: z.string().min(1, "Transition target state is required"),
+  event: z.string().min(1, "Transition event is required"),
+  eventId: EventIdSchema.optional(),
+  guard: ExpressionSchema.nullish(),
+  effects: z.array(EffectSchema).optional(),
+  ensures: SExprListSchema.optional(),
+  description: z.string().nullish(),
+  awaitRender: z.array(AwaitRenderSchema).optional()
+});
+var StateMachineSchema = z.object({
+  states: z.array(StateSchema).min(1, "At least one state is required"),
+  events: z.array(EventSchema),
+  transitions: z.array(TransitionSchema),
+  guards: z.array(GuardSchema).optional()
+});
+function isCircuitEvent(event) {
+  return !event.startsWith("_");
+}
+var TraitConfigValueSchema = z.lazy(
+  () => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(TraitConfigValueSchema),
+    z.record(z.string(), TraitConfigValueSchema)
+  ])
+);
+var TraitConfigSchema = z.record(z.string(), TraitConfigValueSchema);
+function isCallSiteConfigDeclaration(entry) {
+  return typeof entry === "object" && entry !== null && !Array.isArray(entry) && "type" in entry && typeof entry.type === "string" && "default" in entry;
+}
+function isConfigRedeclaration(entry) {
+  if (!isCallSiteConfigDeclaration(entry)) return false;
+  if (entry.wired === true) return false;
+  return entry.type !== "unknown" || entry.label !== void 0 || entry.description !== void 0 || entry.synonyms !== void 0 || entry.tier !== void 0;
+}
+var CONFIG_DECLARATION_META_KEYS = ["label", "description", "tier", "synonyms", "values"];
+function isConfigFieldSchema(entry) {
+  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return false;
+  if (!("type" in entry) || typeof entry.type !== "string") return false;
+  return "default" in entry || CONFIG_DECLARATION_META_KEYS.some((k) => k in entry);
+}
+function normalizeCallSiteConfigToValues(config) {
+  if (config === void 0) {
+    return void 0;
+  }
+  const out = {};
+  let hasAny = false;
+  for (const [key, entry] of Object.entries(config)) {
+    const value = isConfigFieldSchema(entry) ? entry.default : entry;
+    if (value !== void 0) {
+      out[key] = value;
+      hasAny = true;
+    }
+  }
+  return hasAny ? out : void 0;
+}
+function mergeCallSiteConfigOverrides(base, overrides) {
+  const next = {};
+  for (const [k, entry] of Object.entries(base)) {
+    next[k] = isConfigFieldSchema(entry) ? entry : { type: "unknown", default: entry };
+  }
+  for (const [k, v] of Object.entries(overrides)) {
+    if (isCallSiteConfigDeclaration(v)) {
+      next[k] = v;
+      continue;
+    }
+    const existing = base[k];
+    next[k] = existing !== void 0 && isConfigFieldSchema(existing) ? { ...existing, default: v } : { type: "unknown", default: v };
+  }
+  return next;
+}
+var REFERENCE_CONFIG_TYPES = ["entity", "trait", "event"];
+function isReferenceConfigType(type) {
+  return REFERENCE_CONFIG_TYPES.includes(type);
+}
+var SECRET_CONFIG_TYPES = ["secret"];
+function isSecretConfigType(type) {
+  return SECRET_CONFIG_TYPES.includes(type);
+}
+function maskSecretConfigValues(config, values) {
+  const masked = {};
+  for (const [key, value] of Object.entries(values)) {
+    const decl = config[key];
+    if (decl !== void 0 && isSecretConfigType(decl.type) && typeof value === "string" && value.length > 0) {
+      masked[key] = value.length > 4 ? `\u2022\u2022\u2022\u2022${value.slice(-4)}` : "\u2022\u2022\u2022\u2022";
+    } else {
+      masked[key] = value;
+    }
+  }
+  return masked;
+}
+function canonicalizeUnboundTraitOverride(fieldType, value) {
+  return fieldType === "trait" && value === "none" ? null : value;
+}
+function overrideDeclaredKnobs(declared, overrides) {
+  const out = { ...declared };
+  for (const key of Object.keys(overrides)) {
+    const field = declared[key];
+    if (field === void 0) {
+      throw new Error(
+        `overrideDeclaredKnobs: config override "${key}" is not a declared knob (ORB_O_CONFIG_UNKNOWN_KEY). Declared: ${Object.keys(declared).join(", ") || "(none)"}`
+      );
+    }
+    out[key] = { ...field, default: canonicalizeUnboundTraitOverride(field.type, overrides[key]) };
+  }
+  return out;
+}
+var ConfigFieldItemsDeclarationSchema = z.lazy(
+  () => z.object({
+    nullable: z.boolean().optional(),
+    additionalProperties: EntityFieldSchema.optional(),
+    type: z.string().optional(),
+    properties: z.record(z.string(), TraitEntityFieldSchema).optional(),
+    items: ConfigFieldItemsDeclarationSchema.optional(),
+    values: z.array(z.string()).optional()
+  })
+);
+var ConfigFieldDeclarationSchema = z.object({
+  nullable: z.boolean().optional(),
+  additionalProperties: EntityFieldSchema.optional(),
+  type: z.string(),
+  default: TraitConfigValueSchema.optional(),
+  refId: z.string().optional(),
+  required: z.boolean().optional(),
+  label: z.string().optional(),
+  description: z.string().optional(),
+  tier: z.string().optional(),
+  values: z.array(z.string()).optional(),
+  synonyms: z.string().optional(),
+  items: ConfigFieldItemsDeclarationSchema.optional(),
+  properties: z.lazy(() => z.record(z.string(), TraitEntityFieldSchema)).optional(),
+  forwardedFrom: z.string().optional(),
+  nestedForwardedFrom: z.array(z.string()).optional(),
+  payloadFor: z.string().optional(),
+  projectedFrom: FieldProjectionSchema.optional(),
+  record: z.string().optional(),
+  wired: z.boolean().optional()
+});
+var DeclaredTraitConfigSchema = z.record(
+  z.string(),
+  ConfigFieldDeclarationSchema
+);
+var TRAIT_FIELD_TYPES = [
+  "string",
+  "number",
+  "boolean",
+  "date",
+  "array",
+  "object",
+  "timestamp",
+  "datetime",
+  "instant",
+  "enum",
+  "email",
+  "url",
+  "phone",
+  "uuid",
+  "image",
+  "bytes",
+  "trait",
+  "slot",
+  "pattern",
+  "node",
+  "event",
+  "EventAddress",
+  "CallKey",
+  "SExpr",
+  "union",
+  "tuple",
+  "field"
+];
+var TraitEntityFieldSchema = z.object({
+  nullable: z.boolean().optional(),
+  additionalProperties: EntityFieldSchema.optional(),
+  name: z.string().min(1),
+  type: z.union([z.enum(TRAIT_FIELD_TYPES), TypeVariableSchema]),
+  required: z.boolean().optional(),
+  default: TraitConfigValueSchema.optional(),
+  values: z.array(z.string()).optional(),
+  items: ConfigFieldItemsDeclarationSchema.optional(),
+  properties: z.lazy(() => z.record(z.string(), TraitEntityFieldSchema)).optional(),
+  record: z.string().optional()
+});
+var TraitDataEntitySchema = z.object({
+  name: z.string().min(1),
+  collection: z.string().optional(),
+  fields: z.array(TraitEntityFieldSchema).min(1),
+  timestamps: z.boolean().optional(),
+  description: z.string().optional(),
+  runtime: z.boolean().optional(),
+  singleton: z.boolean().optional(),
+  pages: z.array(z.string()).optional()
+});
+var DURATION_INTERVAL = /^\d+(ms|s|m|h|d)$/;
+var CRON_INTERVAL = /^\S+(\s+\S+){4}$/;
+var TickIntervalSchema = z.union([
+  z.literal("frame"),
+  z.number().positive(),
+  z.string().refine((v) => DURATION_INTERVAL.test(v) || CRON_INTERVAL.test(v), {
+    message: 'interval must be "frame", a positive number of milliseconds, a duration ("500ms"/"5s"/"1m"/"1h"/"1d"), or a 5-field cron expression ("0 9 * * *")'
+  })
+]);
+var TraitTickSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().optional(),
+  priority: z.number().optional(),
+  interval: TickIntervalSchema,
+  appliesTo: z.array(z.string()).optional(),
+  runsInBackground: z.boolean().optional(),
+  whileVisible: z.boolean().optional(),
+  pages: z.array(z.string()).optional(),
+  pageIds: z.array(PageIdSchema).optional(),
+  guard: ExpressionSchema.optional(),
+  effects: z.array(EffectSchema).min(1),
+  emits: z.array(z.string()).optional(),
+  emitIds: z.array(EventIdSchema).optional()
+});
+var EventScopeSchema = z.enum(["internal", "external"]);
+var EventPayloadTypeMemberSchema = PayloadFieldDescriptorSchema;
+var EventPayloadFieldSchema = PayloadFieldSchema;
+var CONFIG_REF_EVENT_PATTERN = /^@config\.[A-Za-z_][A-Za-z0-9_]*$/;
+function configRefEventKnob(event) {
+  return CONFIG_REF_EVENT_PATTERN.test(event) ? event.slice("@config.".length) : void 0;
+}
+function resolveConfigRefEventName(event, declaredConfig, effectiveConfig) {
+  const knob = configRefEventKnob(event);
+  if (knob === void 0) return { ok: false, error: "unknown-knob" };
+  const field = declaredConfig?.[knob];
+  if (field === void 0) return { ok: false, error: "unknown-knob" };
+  if (field.type !== "string" && field.type !== "event") return { ok: false, error: "not-string" };
+  if (field.default === void 0) return { ok: false, error: "no-default" };
+  const value = effectiveConfig[knob];
+  if (typeof value !== "string") return { ok: false, error: "not-string" };
+  return { ok: true, value };
+}
+var TraitEventContractSchema = z.object({
+  /**
+   * Event name. Mirrors the Rust validator's `is_valid_event_identifier`:
+   * starts with a letter, then any letters / digits / underscores. Both
+   * UPPER_SNAKE_CASE and PascalCase shapes are valid identifiers in the
+   * post-Phase 2.5 nominal-event type system (events declared via
+   * `type X = Event<T>`). A pre-resolution `@config.<knob>` reference
+   * (Option B) is also legal — inline/resolve substitutes it with the
+   * knob's effective literal before codegen/runtime consume it.
+   */
+  event: z.string().min(1).regex(
+    /^([A-Za-z][A-Za-z0-9_]*|@config\.[A-Za-z_][A-Za-z0-9_]*)$/,
+    "Event name must start with a letter and contain only letters, digits, and underscores, or be a `@config.<knob>` reference"
+  ),
+  eventId: EventIdSchema.optional(),
+  description: z.string().optional(),
+  synonyms: z.string().optional(),
+  tier: z.string().optional(),
+  definerKnob: z.string().optional(),
+  scopeOverridden: z.boolean().optional(),
+  payloadSchema: z.array(EventPayloadFieldSchema).optional(),
+  payloadEntity: z.string().optional(),
+  scope: EventScopeSchema.optional()
+});
+var ListenSourceSchema = z.union([
+  z.object({ kind: z.literal("any") }),
+  z.object({
+    kind: z.literal("trait"),
+    trait: z.string().min(1),
+    traitId: TraitIdSchema.optional()
+  }),
+  z.object({
+    kind: z.literal("orbital"),
+    orbital: z.string().min(1),
+    trait: z.string().min(1),
+    orbitalId: OrbitalIdSchema.optional(),
+    traitId: TraitIdSchema.optional()
+  })
+]);
+function splitEventAddress(raw) {
+  const parts = raw.split(".");
+  if (parts.length <= 1) return { event: raw };
+  if (parts.length === 2) {
+    const [src, event] = parts;
+    return src === "*" ? { event, source: { kind: "any" } } : { event, source: { kind: "trait", trait: src } };
+  }
+  const n = parts.length;
+  return {
+    event: parts[n - 1],
+    source: { kind: "orbital", orbital: parts.slice(0, n - 2).join("."), trait: parts[n - 2] }
+  };
+}
+function joinEventAddress(event, source) {
+  if (source === void 0) return event;
+  switch (source.kind) {
+    case "any":
+      return `*.${event}`;
+    case "trait":
+      return `${source.trait}.${event}`;
+    case "orbital":
+      return `${source.orbital}.${source.trait}.${event}`;
+  }
+}
+var TraitEventListenerSchema = z.object({
+  event: z.string().min(1),
+  eventId: EventIdSchema.optional(),
+  triggers: z.string().min(1),
+  triggersId: EventIdSchema.optional(),
+  description: z.string().optional(),
+  synonyms: z.string().optional(),
+  tier: z.string().optional(),
+  guard: ExpressionSchema.optional(),
+  scope: EventScopeSchema.optional(),
+  payloadMapping: z.record(z.string(), SExprSchema).optional(),
+  key: SExprSchema.optional(),
+  source: ListenSourceSchema.optional()
+});
+var RequiredFieldSchema = z.object({
+  name: z.string().min(1),
+  type: z.union([z.enum(TRAIT_FIELD_TYPES), TypeVariableSchema]),
+  description: z.string().optional()
+});
+var TraitReferenceObjectSchema = z.object({
+  ref: z.string().min(1),
+  refId: TraitIdSchema.optional(),
+  // V4 local declaration id (see the interface doc) — declared so the
+  // strip-mode zod gate carries it through instead of dropping it.
+  id: TraitIdSchema.optional(),
+  // Phase 1.2: optional registry path disambiguator, pairs with `ref`.
+  from: z.string().optional(),
+  linkedEntity: z.string().optional(),
+  linkedEntityId: EntityIdSchema.optional(),
+  name: z.string().optional(),
+  events: z.record(
+    z.string().min(1, "events key (atom event name) must be non-empty"),
+    z.string().min(1, "events value (caller event name) must be non-empty")
+  ).optional(),
+  eventIds: z.record(z.string().min(1), EventIdSchema).optional(),
+  _resolved: z.lazy(() => TraitSchema).optional(),
+  // 3-II type-parameter arguments (see `TraitReference.typeArgs`).
+  typeArgs: z.record(
+    z.string().min(1, "typeArgs key (declared param name) must be non-empty"),
+    z.string().min(1, "typeArgs value (type name) must be non-empty")
+  ).optional(),
+  fields: z.record(
+    z.string().min(1, "fields key (canonical field name) must be non-empty"),
+    z.string().min(1, "fields value (consumer field name) must be non-empty")
+  ).optional(),
+  // Each value is either a plain wiring value (TraitConfigValue) or an
+  // annotated ConfigFieldDeclaration. Declaration form is tried first
+  // (it's more specific — has a `"type"` string key); plain values fall
+  // through to the recursive TraitConfigValue union.
+  config: z.record(z.string(), z.union([ConfigFieldDeclarationSchema, TraitConfigValueSchema])).optional(),
+  appliesTo: z.array(z.string()).optional(),
+  // Phase F.7: caller-supplied listen entries are already-resolved
+  // structured definitions (see `TraitReference.listens`).
+  listens: z.array(TraitEventListenerSchema).optional(),
+  emitsScope: z.enum(["internal", "external"]).optional(),
+  // Phase F.8: per-transition effects override. The keys are event
+  // names (the transition triggers AFTER renames); values are SExpr
+  // effect tuples.
+  effects: z.record(
+    z.string().min(1, "effects override key (event name) must be non-empty"),
+    z.array(SExprSchema)
+  ).optional()
+});
+var TraitReferenceSchema = TraitReferenceObjectSchema.refine(
+  (ref) => {
+    if (!ref.events) return true;
+    for (const [from, to] of Object.entries(ref.events)) {
+      if (from.length === 0 || to.length === 0) return false;
+    }
+    return true;
+  },
+  {
+    message: 'TraitReference "events" entries must have non-empty atom and caller event names',
+    path: ["events"]
+  }
+);
+var TraitUIBindingSchema = z.record(
+  z.string(),
+  z.object({
+    presentation: z.enum(["modal", "drawer", "popover", "inline", "confirm-dialog"]),
+    content: z.union([PatternObjectSchema, z.array(PatternObjectSchema)]),
+    props: z.object({
+      size: z.enum(["sm", "md", "lg", "xl", "full"]).optional(),
+      position: z.enum(["left", "right", "top", "bottom", "center"]).optional(),
+      title: z.string().optional(),
+      closable: z.boolean().optional(),
+      width: z.string().optional(),
+      showProgress: z.boolean().optional(),
+      step: z.number().optional(),
+      totalSteps: z.number().optional()
+    }).optional()
+  })
+);
+var EntityFieldContractSchema = z.object({
+  requires: z.array(z.string()),
+  provides: z.array(z.string())
+});
+var EffectSiteSchema = z.enum(["transition", "tick"]);
+var EffectUseSchema = z.object({
+  kind: z.string(),
+  resource: z.string().optional(),
+  resolved: z.boolean().optional(),
+  site: EffectSiteSchema.optional()
+});
+var EffectRowSchema = z.array(EffectUseSchema);
+var DispatchModeSchema = z.enum(["persistedAwaited", "hybridClientOnly", "runtimeOptimistic"]);
+var TraitDispatchModeSchema = z.enum(["client", "optimistic", "server"]);
+var SourceDeclarationMetadataSchema = z.object({
+  traitId: z.string().min(1),
+  fingerprint: z.string().min(1)
+});
+var SourceBehaviorMetadataSchema = z.object({
+  behavior: z.string().min(1),
+  alias: z.string().min(1),
+  originalName: z.string().min(1)
+});
+var TraitTypeParamDefSchema = z.object({
+  name: z.string().min(1),
+  kind: z.string().min(1),
+  default: z.string().optional()
+});
+var TraitSchema = z.object({
+  id: TraitIdSchema.optional(),
+  name: z.string().min(1),
+  description: z.string().optional(),
+  description_visual_prompt: z.string().optional(),
+  entityRebindable: z.boolean().optional(),
+  entityContract: EntityFieldContractSchema.optional(),
+  effectRow: EffectRowSchema.optional(),
+  entityBindingDescription: z.string().optional(),
+  entityBindingSynonyms: z.string().optional(),
+  dispatch: TraitDispatchModeSchema.optional(),
+  linkedEntity: z.string().optional(),
+  linkedEntityId: EntityIdSchema.optional(),
+  entityRefIds: z.record(z.string().min(1), EntityIdSchema).optional(),
+  traitEmbedIds: z.record(z.string().min(1), TraitIdSchema).optional(),
+  requiredFields: z.array(RequiredFieldSchema).optional(),
+  dataEntities: z.array(TraitDataEntitySchema).optional(),
+  stateMachine: StateMachineSchema.optional(),
+  initialEffects: z.array(EffectSchema).optional(),
+  ticks: z.array(TraitTickSchema).optional(),
+  emits: z.array(TraitEventContractSchema).optional(),
+  listens: z.array(TraitEventListenerSchema).optional(),
+  /** Call-site rename map (`events { ACTION: CONFIRM_VOID }`) — mirrors `Trait.events`. */
+  events: z.record(z.string().min(1), z.string().min(1)).optional(),
+  ui: TraitUIBindingSchema.optional(),
+  config: DeclaredTraitConfigSchema.optional(),
+  sourceBehavior: SourceBehaviorMetadataSchema.optional(),
+  sourceDeclaration: SourceDeclarationMetadataSchema.optional(),
+  sourceEntityDefinition: EntitySchema.optional(),
+  typeParams: z.array(TraitTypeParamDefSchema).optional()
+});
+var TraitRefSchema = z.union([
+  z.string().min(1),
+  TraitReferenceSchema,
+  TraitSchema
+  // Allow inline trait definitions
+]);
+function isInlineTrait(traitRef) {
+  return typeof traitRef === "object" && "name" in traitRef && !("ref" in traitRef);
+}
+function getTraitName(traitRef) {
+  if (typeof traitRef === "string") {
+    return traitRef;
+  }
+  if (isInlineTrait(traitRef)) {
+    return traitRef.name;
+  }
+  return traitRef.ref;
+}
+function getTraitConfig(traitRef) {
+  if (typeof traitRef === "string") {
+    return void 0;
+  }
+  if (isInlineTrait(traitRef)) {
+    return void 0;
+  }
+  return traitRef.config;
+}
+function normalizeTraitRef(traitRef) {
+  if (typeof traitRef === "string") {
+    return { ref: traitRef };
+  }
+  if (isInlineTrait(traitRef)) {
+    return { ref: traitRef.name };
+  }
+  return traitRef;
+}
+var OrbitalTraitRefSchema = TraitRefSchema;
+var ViewTypeSchema = z.enum([
+  "list",
+  "detail",
+  "create",
+  "edit",
+  "dashboard",
+  "custom"
+]);
+var PageTraitRefSchema = z.object({
+  ref: z.string().min(1, "Trait ref is required"),
+  refId: TraitIdSchema.optional(),
+  linkedEntity: z.string().optional(),
+  linkedEntityId: EntityIdSchema.optional(),
+  config: TraitConfigSchema.optional()
+});
+var PageAccessSchema = z.enum(["public", "authenticated"]);
+var PageIndexingSchema = z.enum(["index", "noindex"]);
+var PageMetaSchema = z.union([
+  z.string(),
+  z.tuple([z.literal("i18n/t"), z.string().min(1)])
+]);
+function resolvePageMeta(meta, lookup) {
+  if (meta === void 0) return void 0;
+  return typeof meta === "string" ? meta : lookup(meta[1]);
+}
+var PageModifiersSchema = z.object({
+  access: PageAccessSchema.optional(),
+  indexing: PageIndexingSchema.optional(),
+  title: PageMetaSchema.optional(),
+  description: PageMetaSchema.optional(),
+  translationOf: z.string().min(1).optional(),
+  label: z.string().optional(),
+  icon: z.string().optional(),
+  roles: z.array(z.string().min(1)).min(1).optional()
+}).strict();
+var OrbitalPageStrictSchema = z.object({
+  id: PageIdSchema.optional(),
+  name: z.string().min(1, "Page name is required"),
+  path: z.string().min(1, "Page path is required").startsWith("/", "Path must start with /"),
+  primaryEntity: z.string().min(1, "Primary entity is required"),
+  traits: z.array(PageTraitRefSchema).min(1, "Page must have at least one trait"),
+  title: PageMetaSchema.optional(),
+  description: PageMetaSchema.optional(),
+  access: PageAccessSchema.optional(),
+  indexing: PageIndexingSchema.optional(),
+  sourcePage: z.string().min(1).optional(),
+  translationOf: z.string().min(1).optional(),
+  icon: z.string().optional(),
+  label: z.string().optional(),
+  roles: z.array(z.string().min(1)).min(1).optional()
+}).strict();
+var OrbitalPageSchema = z.object({
+  id: PageIdSchema.optional(),
+  name: z.string().min(1, "Page name is required"),
+  path: z.string(),
+  protocol: z.string().min(1).optional(),
+  address: SExprSchema.optional(),
+  viewType: ViewTypeSchema.optional(),
+  title: PageMetaSchema.optional(),
+  description: PageMetaSchema.optional(),
+  access: PageAccessSchema.optional(),
+  indexing: PageIndexingSchema.optional(),
+  sourcePage: z.string().min(1).optional(),
+  translationOf: z.string().min(1).optional(),
+  primaryEntity: z.string().optional(),
+  traits: z.array(PageTraitRefSchema).optional(),
+  isInitial: z.boolean().optional(),
+  isNotFound: z.boolean().optional(),
+  icon: z.string().optional(),
+  label: z.string().optional(),
+  roles: z.array(z.string().min(1)).min(1).optional()
+}).strict().superRefine((page, ctx) => {
+  if (page.protocol !== void 0) {
+    if (page.path !== "") ctx.addIssue({ code: "custom", path: ["path"], message: "A protocol page has an empty path; its address says where it is reached" });
+    return;
+  }
+  if (page.address !== void 0) ctx.addIssue({ code: "custom", path: ["address"], message: "A route page takes no address; its path is its address" });
+  if (page.path.length === 0) ctx.addIssue({ code: "custom", path: ["path"], message: "Page path is required" });
+  else if (!page.path.startsWith("/")) ctx.addIssue({ code: "custom", path: ["path"], message: "Path must start with /" });
+});
+var PageSchema = OrbitalPageSchema;
+var ProtocolSideSchema = z.enum(["client", "server", "process", "start"]);
+var ProtocolSpecSchema = z.object({
+  name: z.string().min(1),
+  address: z.array(z.object({ name: z.string().min(1), ty: z.string().min(1), required: z.boolean() }).strict()).optional(),
+  viewer: z.boolean(),
+  grant: z.string().min(1).optional(),
+  side: ProtocolSideSchema
+}).strict();
+var ROUTE_PROTOCOL = "route";
+function isRoutePage(page) {
+  return page.protocol === void 0;
+}
+function protocolName(page) {
+  return page.protocol ?? ROUTE_PROTOCOL;
+}
+var SERVICE_TYPES = ["rest", "socket", "mcp"];
+var ServiceTypeSchema = z.enum(SERVICE_TYPES);
+var RestAuthConfigSchema = z.object({
+  type: z.enum(["api-key", "bearer", "basic", "oauth2"]),
+  keyName: z.string().optional(),
+  location: z.enum(["query", "header"]).optional(),
+  secretEnv: z.string().optional()
+});
+var RestServiceDefSchema = z.object({
+  name: z.string().min(1, "Service name is required"),
+  type: z.literal("rest"),
+  description: z.string().optional(),
+  baseUrl: z.string().url("Base URL must be a valid URL"),
+  headers: z.record(z.string(), z.string()).optional(),
+  auth: RestAuthConfigSchema.optional(),
+  timeout: z.number().positive().optional()
+});
+var SocketEventsSchema = z.object({
+  inbound: z.array(z.string()),
+  outbound: z.array(z.string())
+});
+var SocketServiceDefSchema = z.object({
+  name: z.string().min(1, "Service name is required"),
+  type: z.literal("socket"),
+  description: z.string().optional(),
+  url: z.string().url("WebSocket URL must be valid"),
+  events: SocketEventsSchema,
+  reconnect: z.object({
+    enabled: z.boolean(),
+    maxAttempts: z.number().positive().optional(),
+    delayMs: z.number().positive().optional()
+  }).optional()
+});
+var McpServiceDefSchema = z.object({
+  name: z.string().min(1, "Service name is required"),
+  type: z.literal("mcp"),
+  description: z.string().optional(),
+  serverPath: z.string().min(1, "Server path is required"),
+  capabilities: z.array(z.string()).min(1, "At least one capability is required"),
+  env: z.record(z.string(), z.string()).optional()
+});
+var ServiceDefinitionSchema = z.discriminatedUnion("type", [
+  RestServiceDefSchema,
+  SocketServiceDefSchema,
+  McpServiceDefSchema
+]);
+function isServiceReference(service) {
+  return typeof service === "string";
+}
+function isServiceReferenceObject(service) {
+  return typeof service === "object" && service !== null && "ref" in service && !("type" in service);
+}
+var ServiceRefStringSchema = z.string().regex(
+  /^[A-Z][a-zA-Z0-9]*\.services\.[a-zA-Z][a-zA-Z0-9]*$/,
+  'Service reference must be in format "Alias.services.ServiceName" (e.g., "Weather.services.openweather")'
+);
+var ServiceRefObjectSchema = z.object({
+  ref: ServiceRefStringSchema,
+  description: z.string().optional(),
+  baseUrl: z.string().url("baseUrl override must be a valid URL").optional(),
+  headers: z.record(z.string(), z.string()).optional(),
+  url: z.string().url("url override must be a valid URL").optional(),
+  serverPath: z.string().optional()
+});
+var ServiceRefSchema = z.union([
+  ServiceDefinitionSchema,
+  ServiceRefObjectSchema,
+  ServiceRefStringSchema
+]);
+function parseServiceRef(ref) {
+  const match = ref.match(
+    /^([A-Z][a-zA-Z0-9]*)\.services\.([a-zA-Z][a-zA-Z0-9]*)$/
+  );
+  if (!match) return null;
+  return { alias: match[1], serviceName: match[2] };
+}
+function isRestService(service) {
+  return service.type === "rest";
+}
+function isSocketService(service) {
+  return service.type === "socket";
+}
+function isMcpService(service) {
+  return service.type === "mcp";
+}
+function getServiceNames(services) {
+  return services.map((s) => s.name);
+}
+function findService(services, name) {
+  return services.find((s) => s.name.toLowerCase() === name.toLowerCase());
+}
+function hasService(services, name) {
+  return services.some((s) => s.name.toLowerCase() === name.toLowerCase());
+}
+function credentialStorageKey(identity) {
+  if (typeof identity.name !== "string" || identity.principal !== void 0 && typeof identity.principal !== "string") {
+    throw new Error("credential identity requires string name and principal");
+  }
+  return JSON.stringify([identity.principal ?? null, identity.name]);
+}
+function resolveCredentialStatusIdentity(selection, principal) {
+  if (selection !== null && typeof selection === "object" && !Array.isArray(selection)) {
+    const keys = Reflect.ownKeys(selection);
+    if (keys.length !== 2 || !keys.includes("credential") || !keys.includes("scope") || !("credential" in selection) || !("scope" in selection)) {
+      throw new Error("credential-status: expected { credential, scope: app | user }");
+    }
+    const { credential, scope } = selection;
+    if (typeof credential !== "string" || scope !== "app" && scope !== "user") {
+      throw new Error("credential-status: expected { credential, scope: app | user }");
+    }
+    if (scope === "app") return { name: credential };
+    if (principal === void 0) throw new Error("credential-status: nobody is signed in");
+    return { name: credential, principal };
+  }
+  if (principal === void 0) throw new Error("credential-status: nobody is signed in");
+  if (typeof selection !== "string") throw new Error("credential-status: the credential must be a secret knob's name");
+  return { name: selection, principal };
+}
+function credentialStatusConnected(value, principal) {
+  return value !== void 0 && (principal !== void 0 || value !== "");
+}
+var UseDeclarationSchema = z.object({
+  from: z.string().min(1, "Import source is required"),
+  as: z.string().min(1, "Alias is required").regex(
+    /^[A-Z][a-zA-Z0-9]*$/,
+    'Alias must be PascalCase (e.g., "Health", "GameCore")'
+  ),
+  config: DeclaredTraitConfigSchema.optional(),
+  lazy: z.boolean().optional()
+});
+var LazyTraitSchema = z.object({
+  name: z.string().min(1),
+  dispatchMode: DispatchModeSchema,
+  listens: z.array(TraitEventListenerSchema).optional(),
+  backgroundTicks: z.boolean().optional()
+});
+var LazyPageSchema = z.object({
+  path: z.string().min(1),
+  orbital: z.string().min(1),
+  orbRef: z.string().min(1),
+  links: z.array(z.string()).optional(),
+  protocol: z.string().optional(),
+  after: z.string().optional(),
+  places: z.array(z.string()).optional(),
+  traits: z.array(LazyTraitSchema).optional()
+});
+function expectedEntityName(decl) {
+  switch (decl.kind) {
+    case "entity":
+      return decl.name;
+    case "identity":
+      return decl.name;
+    case "event":
+    case "page":
+    case "state":
+    case "transition":
+    case "config":
+      return void 0;
+  }
+}
+var ExpectDeclarationSchema = z.discriminatedUnion("kind", [
+  z.object({
+    strict: z.boolean().optional(),
+    kind: z.literal("identity"),
+    name: z.string().optional(),
+    shape: z.array(EntityFieldSchema).optional()
+  }),
+  z.object({
+    strict: z.boolean().optional(),
+    kind: z.literal("entity"),
+    name: z.string().min(1, "Expected entity name is required"),
+    shape: z.array(EntityFieldSchema).optional(),
+    persistence: EntityPersistenceSchema.optional(),
+    shared: z.boolean().optional(),
+    browser: z.boolean().optional(),
+    read_policy: SExprSchema.optional(),
+    create_policy: SExprSchema.optional(),
+    update_policy: SExprSchema.optional(),
+    delete_policy: SExprSchema.optional(),
+    access_waivers: z.object({
+      read: z.string().optional(),
+      create: z.string().optional(),
+      update: z.string().optional(),
+      delete: z.string().optional()
+    }).optional(),
+    invariants: z.array(SExprSchema).optional()
+  }),
+  z.object({
+    strict: z.boolean().optional(),
+    kind: z.literal("event"),
+    traitName: z.string().min(1, "Expected event trait name is required"),
+    event: z.string().min(1, "Expected event name is required"),
+    payload: z.array(EventPayloadFieldSchema).optional()
+  }),
+  z.object({
+    strict: z.boolean().optional(),
+    kind: z.literal("page"),
+    path: z.string().min(1, "Expected page path is required"),
+    traits: z.array(z.string().min(1)).optional()
+  }),
+  z.object({
+    strict: z.boolean().optional(),
+    kind: z.literal("state"),
+    traitName: z.string().min(1, "Expected state trait name is required"),
+    state: z.string().min(1, "Expected state name is required"),
+    holds: SExprSchema.optional()
+  }),
+  z.object({
+    strict: z.boolean().optional(),
+    kind: z.literal("transition"),
+    traitName: z.string().min(1, "Expected transition trait name is required"),
+    from: z.string().min(1),
+    event: z.string().min(1),
+    to: z.string().min(1),
+    ensures: SExprListSchema.optional()
+  }),
+  z.object({
+    strict: z.boolean().optional(),
+    kind: z.literal("config"),
+    name: z.string().min(1, "Expected config knob name is required"),
+    knob: ConfigFieldDeclarationSchema
+  })
+]);
+var ExpectationDiagnosticSchema = z.object({
+  kind: z.enum(["unknown-orbital", "identity-field-not-declared", "entity-field-not-declared", "event-source-unknown"]),
+  orbital: z.string(),
+  entity: z.string().optional(),
+  field: z.string().optional()
+}).strict();
+var OrganismExpectationsSchema = z.record(
+  z.string(),
+  z.object({ expectations: z.array(ExpectDeclarationSchema), diagnostics: z.array(ExpectationDiagnosticSchema) }).strict()
+);
+function isEntityReference(entity) {
+  return typeof entity === "string";
+}
+function isEntityCall(entity) {
+  return typeof entity === "object" && entity !== null && "extends" in entity;
+}
+function isEntityReferenceAny(entity) {
+  return isEntityReference(entity) || isEntityCall(entity);
+}
+var EntityRefStringSchema = z.string().regex(
+  /^[A-Z][a-zA-Z0-9]*(\.orbitals\.[A-Z][a-zA-Z0-9]*)?\.entity$/,
+  'Entity reference must be in format "Alias.entity" (e.g., "Goblin.entity") or "Alias.orbitals.Name.entity"'
+);
+var EntityCallSchema = z.object({
+  extends: z.string().regex(
+    /^[A-Z][a-zA-Z0-9]*\.entity$/,
+    'EntityCall "extends" must be in format "Alias.entity"'
+  ),
+  name: z.string().optional(),
+  fields: z.array(EntityFieldSchema).optional(),
+  persistence: EntityPersistenceSchema.optional(),
+  collection: z.string().optional()
+}).refine(
+  (call) => {
+    if (!call.fields) return true;
+    const seen = /* @__PURE__ */ new Set();
+    for (const field of call.fields) {
+      if (field.name === void 0) continue;
+      if (seen.has(field.name)) return false;
+      seen.add(field.name);
+    }
+    return true;
+  },
+  {
+    message: 'EntityCall "fields" override list must not contain duplicate field names',
+    path: ["fields"]
+  }
+);
+var EntityRefSchema = z.union([
+  EntitySchema,
+  EntityRefStringSchema,
+  EntityCallSchema
+]);
+function isPageReferenceString(page) {
+  return typeof page === "string";
+}
+function isPageReferenceObject(page) {
+  return typeof page === "object" && "ref" in page && !("name" in page);
+}
+function isPageReference(page) {
+  return isPageReferenceString(page) || isPageReferenceObject(page);
+}
+var PageRefStringSchema = z.string().regex(
+  /^[A-Z][a-zA-Z0-9]*\.pages\.[A-Z][a-zA-Z0-9]*$/,
+  'Page reference must be in format "Alias.pages.PageName" (e.g., "User.pages.Profile")'
+);
+var PageRefObjectSchema = z.object({
+  ref: PageRefStringSchema,
+  refId: PageIdSchema.optional(),
+  // Phase 1.2: optional registry path disambiguator, pairs with `ref`.
+  from: z.string().optional(),
+  path: z.string().startsWith("/").optional(),
+  linkedEntity: z.string().optional(),
+  linkedEntityId: EntityIdSchema.optional(),
+  traits: z.array(TraitRefSchema).optional(),
+  traitRefIds: z.array(TraitIdSchema).optional(),
+  access: PageAccessSchema.optional(),
+  indexing: PageIndexingSchema.optional(),
+  title: PageMetaSchema.optional(),
+  description: PageMetaSchema.optional(),
+  translationOf: z.string().min(1).optional(),
+  label: z.string().optional(),
+  icon: z.string().optional(),
+  roles: z.array(z.string().min(1)).min(1).optional()
+});
+var PageRefSchema = z.union([
+  PageSchema,
+  PageRefStringSchema,
+  PageRefObjectSchema
+]);
+var OrbitalRefStringSchema = z.string().regex(
+  /^[A-Z][a-zA-Z0-9]*\.orbitals\.[A-Z][a-zA-Z0-9]*$/,
+  'Orbital reference must be "Alias.orbitals.OrbitalName"'
+);
+var OrbitalRefObjectSchema = z.object({
+  ref: OrbitalRefStringSchema,
+  refId: OrbitalIdSchema.optional(),
+  entity: z.string().optional(),
+  fields: z.record(z.string(), z.string()).optional(),
+  pages: z.record(z.string(), z.string()).optional(),
+  pageModifiers: z.record(z.string(), PageModifiersSchema).optional(),
+  omit: z.array(z.string()).optional(),
+  only: z.array(z.string()).optional(),
+  config: DeclaredTraitConfigSchema.optional(),
+  events: z.record(z.string(), z.string()).optional(),
+  roles: z.record(z.string(), z.array(z.string())).optional(),
+  entities: z.record(z.string(), z.string()).optional(),
+  mounts: z.record(z.string(), z.array(z.string())).optional(),
+  extend: z.array(EntityFieldSchema).optional(),
+  mock: z.record(z.string(), z.string()).optional(),
+  retype: z.array(EntityFieldSchema).optional(),
+  persistence: EntityPersistenceSchema.optional(),
+  collection: z.string().optional(),
+  shared: z.boolean().optional(),
+  identity: z.boolean().optional(),
+  browser: z.boolean().optional(),
+  traits: z.record(
+    z.string(),
+    z.object({
+      linkedEntity: z.string().optional(),
+      config: DeclaredTraitConfigSchema.optional(),
+      events: z.record(z.string(), z.string()).optional(),
+      fields: z.record(z.string(), z.string()).optional(),
+      listens: z.array(TraitEventListenerSchema).optional(),
+      emitsScope: EventScopeSchema.optional(),
+      dispatch: TraitDispatchModeSchema.optional()
+    })
+  ).optional(),
+  listens: z.array(TraitEventListenerSchema.extend({ trait: z.string() })).optional()
+});
+function parseOrbitalRef(ref) {
+  const match = ref.match(/^([A-Z][a-zA-Z0-9]*)\.orbitals\.([A-Z][a-zA-Z0-9]*)$/);
+  if (!match) return null;
+  return { alias: match[1], orbitalName: match[2] };
+}
+z.string().regex(
+  /^([A-Z][a-zA-Z0-9]*\.traits\.)?[A-Z][a-zA-Z0-9]*$/,
+  'Trait reference must be "TraitName" or "Alias.traits.TraitName"'
+);
+function isImportedTraitRef(ref) {
+  return /^[A-Z][a-zA-Z0-9]*\.traits\.[A-Z][a-zA-Z0-9]*$/.test(ref);
+}
+function parseImportedTraitRef(ref) {
+  const match = ref.match(/^([A-Z][a-zA-Z0-9]*)\.traits\.([A-Z][a-zA-Z0-9]*)$/);
+  if (!match) return null;
+  return { alias: match[1], traitName: match[2] };
+}
+function parseEntityRef(ref) {
+  const match = ref.match(/^([A-Z][a-zA-Z0-9]*)\.entity$/);
+  if (!match) return null;
+  return { alias: match[1] };
+}
+function parsePageRef(ref) {
+  const match = ref.match(/^([A-Z][a-zA-Z0-9]*)\.pages\.([A-Z][a-zA-Z0-9]*)$/);
+  if (!match) return null;
+  return { alias: match[1], pageName: match[2] };
+}
+var EventListenerSchema = z.object({
+  event: z.string().min(1),
+  triggers: z.string().min(1),
+  guard: z.string().optional()
+});
+var EventSourceSchema = z.object({
+  trait: z.string().min(1),
+  transition: z.string().optional(),
+  tick: z.string().optional()
+});
+var ComputedEventContractSchema = z.object({
+  event: z.string().min(1),
+  originalEvent: z.string().min(1),
+  source: EventSourceSchema,
+  description: z.string().optional(),
+  payload: z.array(EventPayloadFieldSchema).optional()
+});
+var ComputedEventListenerSchema = z.object({
+  event: z.string().min(1),
+  source: EventSourceSchema,
+  triggers: z.string().min(1),
+  guard: ExpressionSchema.optional(),
+  payloadMapping: z.record(z.string(), SExprSchema).optional()
+});
+var TypeAliasMembersSchema = z.union([
+  z.array(EventPayloadFieldSchema),
+  z.tuple([EventPayloadTypeMemberSchema.refine((field) => field.name === "", "An unnamed alias member requires an empty name")])
+]);
+var OrbitalDefinitionSchema = z.object({
+  id: OrbitalIdSchema.optional(),
+  name: z.string().min(1, "Orbital name is required"),
+  description: z.string().optional(),
+  visual_prompt: z.string().optional(),
+  // Import system
+  uses: z.array(UseDeclarationSchema).optional(),
+  // Consumer-side requirement declarations (`.lolo` `expects ...`)
+  expects: z.array(ExpectDeclarationSchema).optional(),
+  spec: z.boolean().optional(),
+  // Theme & Services
+  theme: ThemeRefSchema.optional(),
+  services: z.array(ServiceRefSchema).optional(),
+  // Components (inline or reference)
+  entity: EntityRefSchema,
+  // Mirrors the `OrbitalDefinition.auxiliaryEntities` type field — WAS
+  // undeclared here, so `OrbitalSchemaSchema.safeParse` (every load through
+  // `external-loader.ts`) silently stripped it on every externally-loaded
+  // orbital (zod drops unrecognized keys by default), while a schema parsed
+  // directly via `JSON.parse` kept it. Found via the entity-field auto-merge
+  // rebind-target fallback landing on the wrong entity for any RECURSIVELY
+  // loaded `uses` file (`packages/almadar-runtime/src/resolver/
+  // reference-resolver.ts`'s `mergeImportedEntityFieldsIntoOrbital`).
+  auxiliaryEntities: z.array(EntityRefSchema).optional(),
+  traits: z.array(TraitRefSchema),
+  // A reference-form orbital's pages come from its upstream until inline.
+  pages: z.array(PageRefSchema).default([]),
+  // Event interface (trait-centric model) - computed by resolver
+  emits: z.array(ComputedEventContractSchema).optional(),
+  listens: z.array(ComputedEventListenerSchema).optional(),
+  // Filter for exposed events (trait-centric model)
+  exposes: z.array(z.string()).optional(),
+  osGrants: OsGrantsSchema.optional(),
+  // This orbital's own declared knobs (§4.5)
+  config: DeclaredTraitConfigSchema.optional(),
+  // Transient — set by lowering, cleared by inline/resolve
+  reference: OrbitalRefObjectSchema.optional(),
+  // Context fields - persisted throughout orbital lifecycle
+  domainContext: DomainContextSchema.optional(),
+  design: DesignPreferencesSchema.optional(),
+  suggestedGuards: z.array(SuggestedGuardSchema).optional(),
+  types: z.record(z.string(), TypeAliasMembersSchema).optional()
+}).superRefine((orbital, ctx) => {
+  if (orbital.spec === true) return;
+  const entities = [[orbital.entity, ["entity"]], ...(orbital.auxiliaryEntities ?? []).map((e, i) => [e, ["auxiliaryEntities", i]])];
+  for (const [entity, path] of entities) {
+    if (!isEntityReferenceAny(entity) && entity.fields.length === 0) {
+      ctx.addIssue({ code: "too_small", minimum: 1, origin: "array", inclusive: true, path: [...path, "fields"], message: "At least one field is required" });
+    }
+  }
+});
+var OrbitalSchema = OrbitalDefinitionSchema;
+function unwrapTraitRef(traitRef) {
+  if (typeof traitRef === "string" || isInlineTrait(traitRef) || traitRef._resolved === void 0) {
+    return { trait: traitRef };
+  }
+  return traitRef.config === void 0 ? { trait: traitRef._resolved } : { trait: traitRef._resolved, config: traitRef.config };
+}
+function inlineTraitRefs(orbitals) {
+  return orbitals.map((orbital) => ({
+    ...orbital,
+    traits: orbital.traits.map((traitRef) => {
+      const { trait, config } = unwrapTraitRef(traitRef);
+      if (config === void 0 || typeof trait === "string" || !isInlineTrait(trait)) return trait;
+      return { ...trait, config: mergeCallSiteConfigOverrides(trait.config ?? {}, config) };
+    })
+  }));
+}
+function isOrbitalDefinition(orbital) {
+  return "entity" in orbital;
+}
+var OrbitalUnitSchema = OrbitalSchema;
+var ProtocolSideSchema2 = z.enum(["client", "server", "process", "start"]);
+var ProtocolGrantSchema = z.enum(["net-listen", "stdio"]);
+var ProtocolAddressFieldSchema = z.strictObject({
+  name: z.string().min(1),
+  type: z.string().min(1),
+  required: z.boolean()
+});
+var ProtocolSpecSchema2 = z.strictObject({
+  name: z.string().min(1),
+  address: z.array(ProtocolAddressFieldSchema).nullable(),
+  viewer: z.boolean(),
+  grant: ProtocolGrantSchema.nullable(),
+  side: ProtocolSideSchema2
+});
+
+// src/types/schema.ts
+var HOST_SIGN_IN_ROUTE = "/login";
+function isHostSignInRoute(path) {
+  return path.replace(/\/+$/, "") === HOST_SIGN_IN_ROUTE;
+}
+var SiteMetaSchema = z.object({
+  origin: z.string().url().optional(),
+  icon: z.string().min(1).optional(),
+  name: z.string().min(1).optional(),
+  signIn: z.string().startsWith("/").optional()
+}).strict();
+var ConfigProvenanceRecordSchema = z.object({
+  trait: z.string(),
+  patternPath: z.string().optional(),
+  prop: z.string(),
+  knob: z.string()
+});
+var SchemaMetadataSchema = z.object({
+  version: z.number().optional(),
+  createdAt: z.number().optional(),
+  source: z.string().optional(),
+  updatedAt: z.number().optional(),
+  configProvenance: z.record(z.string(), z.array(ConfigProvenanceRecordSchema)).optional(),
+  messageSources: z.record(z.string(), z.string()).optional(),
+  operatorSites: z.record(z.string(), z.enum(["client", "server", "any"])).optional(),
+  dispatchFacts: z.object({ busExcluded: z.array(z.string()), targetOptions: z.array(z.string()) }).optional(),
+  protocols: z.array(ProtocolSpecSchema2).optional()
+});
+var OrbitalSchemaSchema = z.object({
+  types: z.record(z.string(), TypeAliasMembersSchema).optional(),
+  typeContractVersion: z.literal(1).optional(),
+  resolved: z.object({ orb: z.string(), typeContractVersion: z.literal(2) }).optional(),
+  name: z.string().min(1, "Schema name is required"),
+  description: z.string().optional(),
+  theme: ThemeRefSchema.optional(),
+  themes: z.array(z.string().min(1)).optional(),
+  themeDefinitions: z.array(ThemeDefinitionSchema).optional(),
+  summary: z.string().optional(),
+  version: z.string().optional(),
+  domainContext: DomainContextSchema.optional(),
+  design: DesignPreferencesSchema.optional(),
+  designTokens: DesignTokensSchema,
+  customPatterns: CustomPatternMapSchema,
+  orbitals: z.array(OrbitalSchema).min(1, "At least one orbital is required"),
+  locales: z.array(z.string().min(1)).optional(),
+  messages: z.record(z.string(), z.record(z.string(), z.string())).optional(),
+  publicDir: z.string().min(1).optional(),
+  store: z.string().min(1).optional(),
+  egress: z.array(z.string().min(1)).optional(),
+  osGrants: OsGrantsSchema.optional(),
+  deployment: DeploymentSchema.optional(),
+  inbound: z.array(z.string().min(1)).optional(),
+  site: SiteMetaSchema.optional(),
+  lazyPages: z.array(LazyPageSchema).optional(),
+  services: z.array(ServiceDefinitionSchema).optional(),
+  config: DeclaredTraitConfigSchema.optional(),
+  _metadata: SchemaMetadataSchema.optional(),
+  // V4 identity — optional/dual-carry until the Phase-7 flip. Present on
+  // id-carrying `.orb` files so `parseOrbitalSchema` preserves them instead
+  // of stripping unknown keys.
+  schemaVersion: z.number().optional(),
+  ledger: IdentityLedgerSchema.optional()
+});
+function parseOrbitalSchema(data) {
+  return OrbitalSchemaSchema.parse(data);
+}
+function safeParseOrbitalSchema(data) {
+  return OrbitalSchemaSchema.safeParse(data);
+}
+var TRAITS_SEGMENT = ".traits.";
+var ORBITALS_SEGMENT = ".orbitals.";
+var PASCAL = /^[A-Z][A-Za-z0-9]*$/;
+var SPECIFIER = /^(?:[a-z0-9][a-z0-9-]*(?:\/behaviors)?|\.(?:\/[A-Za-z0-9_-]+)+)\/[A-Za-z0-9][A-Za-z0-9_-]*$/;
+function splitLiteral(raw, segment) {
+  const at = raw.lastIndexOf(segment);
+  if (at <= 0) return void 0;
+  const behavior = raw.slice(0, at);
+  const name = raw.slice(at + segment.length);
+  if (!SPECIFIER.test(behavior) || !PASCAL.test(name)) return void 0;
+  return { behavior, name };
+}
+function parseTraitValueLiteral(raw) {
+  const parts = splitLiteral(raw, TRAITS_SEGMENT);
+  return parts === void 0 ? void 0 : { behavior: parts.behavior, trait: parts.name };
+}
+function parseOrbitalValueLiteral(raw) {
+  const parts = splitLiteral(raw, ORBITALS_SEGMENT);
+  return parts === void 0 ? void 0 : { behavior: parts.behavior, orbital: parts.name };
+}
+function parseBehaviorValueLiteral(raw) {
+  return parseTraitValueLiteral(raw) ?? parseOrbitalValueLiteral(raw);
+}
+function formatTraitValueLiteral(value) {
+  return `${value.behavior}${TRAITS_SEGMENT}${value.trait}`;
+}
+function formatOrbitalValueLiteral(value) {
+  return `${value.behavior}${ORBITALS_SEGMENT}${value.orbital}`;
+}
+function formatBehaviorValueLiteral(value) {
+  return isOrbitalValueShape(value) ? formatOrbitalValueLiteral(value) : formatTraitValueLiteral(value);
+}
+var TraitOverridesSchema = TraitReferenceObjectSchema.pick({
+  config: true,
+  events: true,
+  fields: true,
+  listens: true,
+  emitsScope: true,
+  linkedEntity: true
+}).strict();
+var TraitValueSchema = TraitOverridesSchema.extend({
+  behavior: z.string().regex(SPECIFIER),
+  trait: z.string().regex(PASCAL)
+}).strict();
+var OrbitalValueUseSchema = z.object({ from: z.string(), as: z.string().regex(PASCAL) }).strict();
+var OrbitalValueSiblingSchema = z.object({
+  name: z.string().regex(PASCAL),
+  ref: z.string(),
+  linkedEntity: z.string().optional(),
+  config: z.record(z.string(), TraitConfigValueSchema).optional()
+}).strict();
+var OrbitalOverridesSchema = OrbitalRefObjectSchema.omit({ ref: true, refId: true, config: true, traits: true }).extend({
+  name: z.string().regex(PASCAL).optional(),
+  app: z.record(z.string(), TraitConfigValueSchema).optional(),
+  config: z.record(z.string(), TraitConfigValueSchema).optional(),
+  traits: z.record(z.string(), TraitOverridesSchema).optional(),
+  uses: z.array(OrbitalValueUseSchema).optional(),
+  siblings: z.array(OrbitalValueSiblingSchema).optional()
+}).strict();
+var OrbitalValueSchema = OrbitalOverridesSchema.extend({
+  behavior: z.string().regex(SPECIFIER),
+  orbital: z.string().regex(PASCAL)
+}).strict();
+var BehaviorValueSchema = z.union([TraitValueSchema, OrbitalValueSchema]);
+function mergeTraitOverrides(base, overrides) {
+  const merged = { ...base };
+  if (overrides.config !== void 0) merged.config = { ...base.config, ...overrides.config };
+  if (overrides.events !== void 0) merged.events = { ...base.events, ...overrides.events };
+  if (overrides.fields !== void 0) merged.fields = { ...base.fields, ...overrides.fields };
+  if (overrides.listens !== void 0) merged.listens = overrides.listens;
+  if (overrides.emitsScope !== void 0) merged.emitsScope = overrides.emitsScope;
+  if (overrides.linkedEntity !== void 0) merged.linkedEntity = overrides.linkedEntity;
+  return merged;
+}
+function applyTraitOverrides(value, overrides) {
+  return { ...mergeTraitOverrides(value, overrides), behavior: value.behavior, trait: value.trait };
+}
+function mergeFieldsByName(base, next) {
+  const out = [...base ?? []];
+  for (const field of next) {
+    const at = field.name === void 0 ? -1 : out.findIndex((f) => f.name === field.name);
+    if (at >= 0) out[at] = field;
+    else out.push(field);
+  }
+  return out;
+}
+function applyOrbitalOverrides(value, overrides) {
+  const merged = { ...value, ...overrides, behavior: value.behavior, orbital: value.orbital };
+  if (overrides.app !== void 0) merged.app = { ...value.app, ...overrides.app };
+  if (overrides.config !== void 0) merged.config = { ...value.config, ...overrides.config };
+  if (overrides.events !== void 0) merged.events = { ...value.events, ...overrides.events };
+  if (overrides.fields !== void 0) merged.fields = { ...value.fields, ...overrides.fields };
+  if (overrides.pages !== void 0) merged.pages = { ...value.pages, ...overrides.pages };
+  if (overrides.pageModifiers !== void 0) merged.pageModifiers = { ...value.pageModifiers, ...overrides.pageModifiers };
+  if (overrides.roles !== void 0) merged.roles = { ...value.roles, ...overrides.roles };
+  if (overrides.entities !== void 0) merged.entities = { ...value.entities, ...overrides.entities };
+  if (overrides.mounts !== void 0) merged.mounts = { ...value.mounts, ...overrides.mounts };
+  if (overrides.mock !== void 0) merged.mock = { ...value.mock, ...overrides.mock };
+  if (overrides.extend !== void 0) merged.extend = mergeFieldsByName(value.extend, overrides.extend);
+  if (overrides.retype !== void 0) merged.retype = mergeFieldsByName(value.retype, overrides.retype);
+  if (overrides.uses !== void 0) {
+    const byAlias = new Map((value.uses ?? []).map((u) => [u.as, u]));
+    for (const use of overrides.uses) byAlias.set(use.as, use);
+    merged.uses = [...byAlias.values()];
+  }
+  if (overrides.siblings !== void 0) {
+    const byName = new Map((value.siblings ?? []).map((t) => [t.name, t]));
+    for (const sibling of overrides.siblings) {
+      const prior = byName.get(sibling.name);
+      byName.set(sibling.name, { ...prior, ...sibling, ...prior?.config !== void 0 || sibling.config !== void 0 ? { config: { ...prior?.config, ...sibling.config } } : {} });
+    }
+    merged.siblings = [...byName.values()];
+  }
+  if (overrides.traits !== void 0) {
+    const traits = { ...value.traits };
+    for (const [name, entry] of Object.entries(overrides.traits)) {
+      traits[name] = mergeTraitOverrides(traits[name] ?? {}, entry);
+    }
+    merged.traits = traits;
+  }
+  return merged;
+}
+function applyBehaviorOverrides(value, overrides) {
+  if (isOrbitalValueShape(value)) return applyOrbitalOverrides(value, OrbitalOverridesSchema.parse(overrides));
+  return applyTraitOverrides(value, TraitOverridesSchema.parse(overrides));
+}
+function isTraitValue(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  if (!("behavior" in value) || !("trait" in value)) return false;
+  const { behavior, trait } = value;
+  return typeof behavior === "string" && SPECIFIER.test(behavior) && typeof trait === "string" && PASCAL.test(trait);
+}
+function isOrbitalValue(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  if (!("behavior" in value) || !("orbital" in value)) return false;
+  const { behavior, orbital } = value;
+  return typeof behavior === "string" && SPECIFIER.test(behavior) && typeof orbital === "string" && PASCAL.test(orbital);
+}
+function behaviorRef(specifier) {
+  if (!SPECIFIER.test(specifier)) {
+    throw new Error(`behavior/ref: "${specifier}" is not a behavior specifier (<prefix>/<name>, std/behaviors/<name> or ./<dir>/<name>)`);
+  }
+  return { behavior: specifier };
+}
+function isBehaviorRefValue(value) {
+  return BehaviorRefSchema.safeParse(value).success;
+}
+function isOrbitalValueShape(value) {
+  return "orbital" in value;
+}
+var EXPOSURES = ["app", "experience", "palette", "both", "internal"];
+var VectorSchema = z.array(z.number());
+var CatalogScopeSchema = z.object({
+  paths: z.array(z.string().min(1)).min(1),
+  exposure: z.array(z.enum(EXPOSURES)).optional()
+}).strict();
+var BehaviorRefSchema = z.object({ behavior: z.string().regex(SPECIFIER) }).strict();
+var CatalogEntrySchema = z.object({
+  /** `<prefix>/<name>`. */
+  behavior: z.string(),
+  package: z.string(),
+  topic: z.string(),
+  level: z.enum(["atom", "molecule", "organism"]),
+  exposure: z.enum(EXPOSURES).optional(),
+  /** The `@almadar/ui` pattern the behavior is the factory of (`;; @pattern`); absent when it is not one. */
+  pattern: z.string().optional(),
+  description: z.string(),
+  capabilities: z.array(z.string()),
+  /** The behavior's traits as ready-to-bind values; absent in a listing asked for without traits (`traits: false`). */
+  traits: z.array(TraitValueSchema).optional(),
+  /** The behavior as a value (`.lolo` type `behavior`), ready to store. */
+  value: BehaviorRefSchema,
+  /** Shipped embedding vectors, keyed by facet (`description`, `capabilities`). */
+  vectors: z.record(z.string(), VectorSchema),
+  /** The embedding model the vectors were stamped with. */
+  model: z.string()
+}).strict();
+var TraitKnobSchema = z.object({
+  key: z.string(),
+  type: z.string(),
+  default: TraitConfigValueSchema.optional(),
+  label: z.string().optional(),
+  description: z.string().optional(),
+  tier: z.string().optional(),
+  vector: VectorSchema.optional()
+}).strict();
+var TraitEventsSchema = z.object({
+  emits: z.array(z.string()),
+  listens: z.array(z.string()),
+  transitions: z.array(z.string()),
+  domain: z.array(z.string()).optional()
+}).strict();
+var TraitMachineObject = z.object({
+  linkedEntity: z.string().optional(),
+  stateMachine: StateMachineSchema
+}).strict();
+var TraitMachineSchema = TraitMachineObject;
+var TraitSourceSchema = z.object({
+  text: z.string(),
+  transitions: z.array(z.object({ index: z.number().int(), start: z.number().int(), end: z.number().int() }).strict())
+}).strict();
+var TraitDescriptionObject = z.object({
+  value: TraitValueSchema,
+  knobs: z.array(TraitKnobSchema),
+  events: TraitEventsSchema,
+  machine: TraitMachineSchema.optional(),
+  source: TraitSourceSchema.optional(),
+  model: z.string()
+}).strict();
+var TraitDescriptionSchema = TraitDescriptionObject;
+var DescribeTargetSchema = z.union([TraitValueSchema, OrbitalValueSchema, BehaviorRefSchema]);
+var KnobFieldSchema = z.lazy(
+  () => z.object({
+    name: z.string(),
+    type: z.string(),
+    required: z.boolean().optional(),
+    values: z.array(z.string()).optional(),
+    properties: z.array(KnobFieldSchema).optional(),
+    default: TraitConfigValueSchema.optional(),
+    label: z.string().optional(),
+    description: z.string().optional(),
+    synonyms: z.string().optional(),
+    tier: z.string().optional(),
+    forwardedFrom: z.string().optional()
+  }).strict()
+);
+var OrbitalDescriptionSchema = z.object({
+  value: OrbitalValueSchema,
+  config: DeclaredTraitConfigSchema,
+  knobs: z.array(KnobFieldSchema),
+  entity: z.object({ name: z.string(), fields: z.array(EntityFieldSchema), identity: z.boolean().optional(), persistence: EntityPersistenceSchema.optional() }).strict().optional(),
+  /** Entities a sibling orbital owns that this one references: what an import of it maps through `entities {}`. */
+  borrows: z.array(z.string()),
+  /** What the orbital needs from its siblings at runtime, derived by `orb` (identity, entities, pages, events). */
+  expects: z.array(ExpectDeclarationSchema),
+  traits: z.array(z.object({
+    trait: z.string(),
+    config: DeclaredTraitConfigSchema,
+    knobs: z.array(KnobFieldSchema),
+    events: TraitEventsSchema,
+    /** Declared `-> @rebindable`: the trait may be bound to another record. */
+    rebindable: z.boolean().optional(),
+    /** The upstream trait this one composes (`trait X = Alias.traits.Y`), as written; absent for a trait the behavior defines itself. */
+    ref: z.string().optional(),
+    /** The trait's declared `@capabilities` tags. */
+    capabilities: z.array(z.string()).optional()
+  }).strict()),
+  /** Each page with the traits it mounts: what the behavior declares as standing on its own. */
+  pages: z.array(z.object({ name: z.string(), path: z.string(), traits: z.array(z.string()).optional(), label: z.string().optional(), icon: z.string().optional() }).strict()),
+  /** Controls the orbital leaves for an embedding organism (`emitsScope external`) that nothing in it handles: an importer must route each. */
+  forwards: z.array(z.object({ trait: z.string(), event: z.string(), via: z.array(z.string()) }).strict()).optional()
+}).strict();
+var BehaviorDescriptionSchema = z.object({
+  behavior: z.string(),
+  config: DeclaredTraitConfigSchema,
+  knobs: z.array(KnobFieldSchema),
+  orbitals: z.array(OrbitalDescriptionSchema),
+  /** The behaviors this one imports (`uses … from`): what it already contains. */
+  uses: z.array(z.string()).optional()
+}).strict();
+
+export { AwaitRenderSchema, BehaviorDescriptionSchema, BehaviorRefSchema, BehaviorValueSchema, CONFIG_REF_EVENT_PATTERN, CatalogEntrySchema, CatalogScopeSchema, ComputedEventContractSchema, ComputedEventListenerSchema, ConfigFieldDeclarationSchema, ConfigProvenanceRecordSchema, DeclaredTraitConfigSchema, DeploymentSchema, DescribeTargetSchema, DispatchModeSchema, EntityCallSchema, EntityFieldContractSchema, EntityRefSchema, EntityRefStringSchema, EventListenerSchema, EventPayloadFieldSchema, EventSchema, EventScopeSchema, EventSourceSchema, ExpectDeclarationSchema, ExpectationDiagnosticSchema, GuardSchema, HOST_SIGN_IN_ROUTE, InboundVerificationSchema, KnobFieldSchema, LazyPageSchema, LazyTraitSchema, ListenSourceSchema, McpServiceDefSchema, OrbitalDefinitionSchema, OrbitalDescriptionSchema, OrbitalOverridesSchema, OrbitalPageSchema, OrbitalPageStrictSchema, OrbitalRefObjectSchema, OrbitalRefStringSchema, OrbitalSchema, OrbitalSchemaSchema, OrbitalTraitRefSchema, OrbitalUnitSchema, OrbitalValueSchema, OrbitalValueSiblingSchema, OrbitalValueUseSchema, OrganismExpectationsSchema, OsGrantsSchema, PageAccessSchema, PageIndexingSchema, PageMetaSchema, PageModifiersSchema, PageRefObjectSchema, PageRefSchema, PageRefStringSchema, PageSchema, PageTraitRefSchema, PayloadFieldSchema, PayloadTypeWhenSchema, ProtocolSideSchema, ProtocolSpecSchema, REFERENCE_CONFIG_TYPES, ROUTE_PROTOCOL, RequiredFieldSchema, RestAuthConfigSchema, RestServiceDefSchema, SECRET_CONFIG_TYPES, SERVICE_TYPES, SKELETON_VARIANTS, SchemaMetadataSchema, ServiceDefinitionSchema, ServiceRefObjectSchema, ServiceRefSchema, ServiceRefStringSchema, ServiceTypeSchema, SiteMetaSchema, SkeletonNodeSchema, SkeletonShapeSchema, SkeletonSpecSchema, SkeletonVariantSchema, SocketEventsSchema, SocketServiceDefSchema, SourceDeclarationMetadataSchema, StateMachineSchema, StateSchema, TickIntervalSchema, TraitConfigSchema, TraitConfigValueSchema, TraitDataEntitySchema, TraitDescriptionSchema, TraitDispatchModeSchema, TraitEntityFieldSchema, TraitEventContractSchema, TraitEventListenerSchema, TraitEventsSchema, TraitKnobSchema, TraitMachineSchema, TraitOverridesSchema, TraitRefSchema, TraitReferenceSchema, TraitSchema, TraitSourceSchema, TraitTickSchema, TraitUIBindingSchema, TraitValueSchema, TransitionSchema, UseDeclarationSchema, ViewTypeSchema, applyBehaviorOverrides, applyOrbitalOverrides, applyTraitOverrides, behaviorRef, configRefEventKnob, credentialStatusConnected, credentialStorageKey, expectedEntityName, findService, formatBehaviorValueLiteral, formatOrbitalValueLiteral, formatTraitValueLiteral, getServiceNames, getTraitConfig, getTraitName, hasService, inlineTraitRefs, isBehaviorRefValue, isCallSiteConfigDeclaration, isCircuitEvent, isConfigFieldSchema, isConfigRedeclaration, isEntityCall, isEntityReference, isEntityReferenceAny, isHostSignInRoute, isImportedTraitRef, isInlineTrait, isMcpService, isOrbitalDefinition, isOrbitalValue, isPageReference, isPageReferenceObject, isPageReferenceString, isReferenceConfigType, isRestService, isRoutePage, isSecretConfigType, isServiceReference, isServiceReferenceObject, isSocketService, isTraitValue, joinEventAddress, maskSecretConfigValues, mergeCallSiteConfigOverrides, normalizeCallSiteConfigToValues, normalizeTraitRef, overrideDeclaredKnobs, parseBehaviorValueLiteral, parseEntityRef, parseImportedTraitRef, parseOrbitalRef, parseOrbitalSchema, parseOrbitalValueLiteral, parsePageRef, parseServiceRef, parseTraitValueLiteral, payloadTypeContainer, protocolName, resolveConfigRefEventName, resolveCredentialStatusIdentity, resolvePageMeta, safeParseOrbitalSchema, splitEventAddress, unionOsGrants, unwrapTraitRef };
+//# sourceMappingURL=chunk-PNGFWLHD.js.map
+//# sourceMappingURL=chunk-PNGFWLHD.js.map