@almadar/core 10.129.0 → 11.0.0

package/dist/chunk-JOHDVS6J.js

@@ -1,1614 +0,0 @@
-// src/i18n/orb-notation.json
-var orb_notation_default = {
-  reason: "Design-system token NAMES reachable only under a theme `tokens` node. They are keys of the .orb schema but notation, not language vocabulary, so they are excluded from the `orb` i18n section (owner ruling 2026-09-07). Regenerate with: pnpm --filter @almadar/core run gen:orb-notation",
-  keys: [
-    "2xl",
-    "3xl",
-    "4xl",
-    "accent",
-    "accentForeground",
-    "accentImage",
-    "awaitingSkeleton",
-    "backdrop",
-    "background",
-    "base",
-    "bodyDefault",
-    "bodyEmphasis",
-    "bodyFamily",
-    "bodyQuiet",
-    "border",
-    "borderHairline",
-    "borderHeavy",
-    "borderHover",
-    "borderStandard",
-    "borderStyle",
-    "borderStyleInteractive",
-    "busyDelay",
-    "buttonHeightLg",
-    "buttonHeightMd",
-    "buttonHeightSm",
-    "caption",
-    "card",
-    "cardElevation",
-    "cardForeground",
-    "cardImage",
-    "cardPaddingLg",
-    "cardPaddingMd",
-    "cardPaddingSm",
-    "corner",
-    "cornerShape",
-    "cornerShapeInteractive",
-    "cornerShapePill",
-    "dash",
-    "defaultSize",
-    "dialogElevation",
-    "dialogPadding",
-    "display-1",
-    "display-2",
-    "displayFamily",
-    "dot",
-    "dramatic",
-    "duration",
-    "durations",
-    "easing",
-    "easings",
-    "edgeHeight",
-    "edgeMask",
-    "emphasized",
-    "emptyAsset",
-    "enter",
-    "enterRise",
-    "enterScale",
-    "enterSlide",
-    "entry",
-    "error",
-    "errorAsset",
-    "errorForeground",
-    "exit",
-    "expand",
-    "family",
-    "fast",
-    "fillOpacity",
-    "fillStyle",
-    "fog",
-    "fontImport",
-    "foreground",
-    "glow",
-    "headingMajor",
-    "headingMinor",
-    "headingShadow",
-    "headingStyle",
-    "headingTracking",
-    "headingTransform",
-    "headingWeight",
-    "hover",
-    "info",
-    "infoForeground",
-    "inputHeightLg",
-    "inputHeightMd",
-    "inputHeightSm",
-    "instant",
-    "intents",
-    "interactiveElevation",
-    "labelCase",
-    "labelFont",
-    "labelSize",
-    "labelWeight",
-    "lg",
-    "lightAmbient",
-    "lightKey",
-    "lightKeyColor",
-    "lineCap",
-    "lineHeight",
-    "lineJoin",
-    "linear",
-    "loadingAsset",
-    "marker",
-    "materialFlat",
-    "materialMetalness",
-    "materialOutline",
-    "materialRoughness",
-    "modalEnter",
-    "modalExit",
-    "monoFamily",
-    "muted",
-    "mutedForeground",
-    "normal",
-    "numeric",
-    "onboardingAsset",
-    "pageEnter",
-    "pageImage",
-    "pageImageSize",
-    "placeholder",
-    "popoverElevation",
-    "popoverEnter",
-    "popoverExit",
-    "press",
-    "pressedElevation",
-    "primary",
-    "primaryForeground",
-    "primaryHover",
-    "radiusContainer",
-    "radiusInteractive",
-    "radiusPill",
-    "ring",
-    "roughness",
-    "rowHeightCompact",
-    "rowHeightNormal",
-    "rowHeightSpacious",
-    "scale",
-    "scrim",
-    "secondary",
-    "secondaryForeground",
-    "secondaryHover",
-    "sectionGap",
-    "shadow",
-    "shapes",
-    "size",
-    "slow",
-    "sm",
-    "space0",
-    "space1",
-    "space10",
-    "space11",
-    "space12",
-    "space2",
-    "space3",
-    "space4",
-    "space5",
-    "space6",
-    "space7",
-    "space8",
-    "space9",
-    "spring",
-    "stagger",
-    "standard",
-    "strokeBold",
-    "strokeNormal",
-    "strokeThin",
-    "strokeWidth",
-    "success",
-    "successForeground",
-    "surfaceHover",
-    "tableBorder",
-    "tableHeader",
-    "tableRowHover",
-    "textureMask",
-    "textureSize",
-    "toastElevation",
-    "toastEnter",
-    "toastExit",
-    "warning",
-    "warningForeground",
-    "weight",
-    "xl",
-    "xs"
-  ]
-};
-
-// src/i18n/en.json
-var en_default = {
-  meta: {
-    code: "en",
-    name: "English",
-    rtl: false
-  },
-  keywords: {
-    app: "app",
-    orbital: "orbital",
-    uses: "uses",
-    expects: "expects",
-    entity: "entity",
-    type: "type",
-    derived: "derived",
-    trait: "trait",
-    initial: "initial",
-    state: "state",
-    for: "for",
-    page: "page",
-    as: "as",
-    theme: "theme",
-    emits: "emits",
-    listens: "listens",
-    ticks: "ticks",
-    config: "config",
-    when: "when",
-    with: "with",
-    from: "from",
-    to: "to",
-    every: "every",
-    capabilities: "capabilities",
-    match: "match",
-    external: "external",
-    internal: "internal",
-    on: "on",
-    name: "name",
-    fields: "fields",
-    events: "events",
-    event: "event",
-    emitsScope: "emitsScope",
-    identity: "identity",
-    pages: "pages",
-    omit: "omit",
-    only: "only",
-    roles: "roles",
-    entities: "entities",
-    extend: "extend",
-    retype: "retype",
-    traits: "traits",
-    mock: "mock",
-    lazy: "lazy",
-    locales: "locales",
-    egress: "egress",
-    store: "store",
-    themes: "themes",
-    public: "public",
-    instances: "instances",
-    access: "access",
-    indexing: "indexing",
-    title: "title",
-    description: "description",
-    origin: "origin",
-    icon: "icon",
-    siteName: "siteName",
-    signIn: "signIn",
-    authenticated: "authenticated",
-    index: "index",
-    noindex: "noindex",
-    version: "version",
-    translationOf: "translationOf",
-    label: "label",
-    inbound: "inbound",
-    answers: "answers",
-    verifies: "verifies",
-    fs: "fs",
-    exec: "exec",
-    net: "net",
-    env: "env",
-    stdio: "stdio",
-    sys: "sys",
-    desktop: "desktop",
-    kv: "kv",
-    deployment: "deployment",
-    input: "input",
-    http: "http",
-    boot: "boot"
-  },
-  shapes: {
-    Entity: "Entity",
-    Trait: "Trait",
-    Page: "Page",
-    Orbital: "Orbital",
-    Event: "Event"
-  },
-  tags: {
-    persistent: "persistent",
-    runtime: "runtime",
-    shared: "shared",
-    client: "client",
-    optimistic: "optimistic",
-    server: "server",
-    browser: "browser",
-    identity: "identity",
-    background: "background",
-    visible: "visible",
-    store: "store"
-  },
-  categories: {},
-  capabilities: {
-    read: "read",
-    write: "write",
-    browse: "browse",
-    create: "create",
-    upsert: "upsert",
-    update: "update",
-    delete: "delete",
-    notify: "notify",
-    schedule: "schedule",
-    invoke: "invoke",
-    batch: "batch"
-  },
-  annotations: {
-    key: "key",
-    unique: "unique",
-    intrinsic: "intrinsic",
-    label: "label",
-    description: "description",
-    synonyms: "synonyms",
-    mock: "mock",
-    tier: "tier",
-    rebindable: "rebindable",
-    read: "read",
-    create: "create",
-    update: "update",
-    delete: "delete",
-    icon: "icon",
-    roles: "roles",
-    invariant: "invariant",
-    holds: "holds",
-    ensures: "ensures"
-  },
-  sigils: {
-    entity: "entity",
-    payload: "payload",
-    state: "state",
-    now: "now",
-    config: "config",
-    user: "user",
-    trait: "trait",
-    event: "event",
-    prevEvents: "prevEvents",
-    prevStates: "prevStates",
-    fromState: "fromState",
-    toState: "toState",
-    fromEntity: "fromEntity",
-    locale: "locale"
-  },
-  effects: {
-    set: "set",
-    fetch: "fetch",
-    persist: "persist",
-    emit: "emit",
-    navigate: "navigate",
-    "navigate-back": "navigate-back",
-    "render-ui": "render-ui",
-    notify: "notify",
-    ref: "ref",
-    "call-service": "call-service",
-    http: "http",
-    redis: "redis",
-    postgres: "postgres",
-    "cancel-call": "cancel-call",
-    invoke: "invoke",
-    do: "do",
-    if: "if",
-    let: "let",
-    fn: "fn",
-    lambda: "lambda",
-    quote: "quote",
-    quasiquote: "quasiquote",
-    unquote: "unquote",
-    match: "match",
-    when: "when",
-    "random-bytes": "random-bytes",
-    "credential-status": "credential-status",
-    "credential-forget": "credential-forget",
-    "credential-list": "credential-list",
-    "credential-set": "credential-set",
-    "credential-remove": "credential-remove",
-    "credential-test": "credential-test",
-    "credential-mode": "credential-mode",
-    "credential-rotate": "credential-rotate",
-    "oauth-authorize": "oauth-authorize",
-    "oauth-connection-status": "oauth-connection-status",
-    "oauth-connection-forget": "oauth-connection-forget"
-  },
-  types: {
-    string: "string",
-    number: "number",
-    int: "int",
-    float: "float",
-    bool: "bool",
-    boolean: "boolean",
-    timestamp: "timestamp",
-    date: "date",
-    datetime: "datetime",
-    duration: "duration",
-    money: "money",
-    file: "file",
-    bytes: "bytes",
-    email: "email",
-    url: "url",
-    phone: "phone",
-    uuid: "uuid",
-    image: "image",
-    icon: "icon",
-    asset: "asset",
-    component: "component",
-    object: "object",
-    array: "array",
-    enum: "enum",
-    relation: "relation",
-    node: "node",
-    union: "union",
-    tuple: "tuple",
-    void: "void",
-    null: "null",
-    any: "any",
-    trait: "trait",
-    orbital: "orbital",
-    behavior: "behavior",
-    entity: "entity",
-    event: "event",
-    EventAddress: "EventAddress",
-    CallKey: "CallKey",
-    field: "field",
-    slot: "slot",
-    pattern: "pattern",
-    Map: "Map",
-    secret: "secret",
-    SExpr: "SExpr"
-  },
-  units: {
-    ms: "ms",
-    s: "s",
-    m: "m",
-    h: "h",
-    d: "d"
-  },
-  literals: {
-    true: "true",
-    false: "false",
-    null: "null"
-  },
-  reservedEvents: {
-    INIT: "INIT"
-  },
-  orb: {
-    _metadata: "_metadata",
-    _resolved: "_resolved",
-    access_waivers: "access_waivers",
-    ensures: "ensures",
-    holds: "holds",
-    invariants: "invariants",
-    alias: "alias",
-    animations: "animations",
-    appliesTo: "appliesTo",
-    as: "as",
-    aspect: "aspect",
-    assetRef: "assetRef",
-    at: "at",
-    auth: "auth",
-    auxiliaryEntities: "auxiliaryEntities",
-    awaitRender: "awaitRender",
-    bakedName: "bakedName",
-    baseUrl: "baseUrl",
-    behavior: "behavior",
-    capabilities: "capabilities",
-    cardinality: "cardinality",
-    category: "category",
-    className: "className",
-    classification: "classification",
-    collection: "collection",
-    color: "color",
-    colors: "colors",
-    columns: "columns",
-    component: "component",
-    config: "config",
-    configProvenance: "configProvenance",
-    container: "container",
-    content: "content",
-    create: "create",
-    create_policy: "create_policy",
-    createdAt: "createdAt",
-    curName: "curName",
-    customPatterns: "customPatterns",
-    darkMode: "darkMode",
-    dataEntities: "dataEntities",
-    default: "default",
-    definerKnob: "definerKnob",
-    delayMs: "delayMs",
-    delete: "delete",
-    delete_policy: "delete_policy",
-    density: "density",
-    description: "description",
-    description_visual_prompt: "description_visual_prompt",
-    design: "design",
-    designTokens: "designTokens",
-    desktop: "desktop",
-    detailPattern: "detailPattern",
-    device: "device",
-    dimension: "dimension",
-    displayName: "displayName",
-    domainContext: "domainContext",
-    effectRow: "effectRow",
-    effects: "effects",
-    elevation: "elevation",
-    emitIds: "emitIds",
-    emits: "emits",
-    emitsScope: "emitsScope",
-    enabled: "enabled",
-    entities: "entities",
-    entity: "entity",
-    entityBindingDescription: "entityBindingDescription",
-    entityBindingSynonyms: "entityBindingSynonyms",
-    entityContract: "entityContract",
-    entityId: "entityId",
-    entityRebindable: "entityRebindable",
-    entityRefIds: "entityRefIds",
-    entries: "entries",
-    env: "env",
-    equals: "equals",
-    event: "event",
-    eventId: "eventId",
-    eventIds: "eventIds",
-    events: "events",
-    exec: "exec",
-    expects: "expects",
-    exposes: "exposes",
-    extend: "extend",
-    retype: "retype",
-    extends: "extends",
-    extendsId: "extendsId",
-    external: "external",
-    field: "field",
-    fields: "fields",
-    fingerprint: "fingerprint",
-    flowPattern: "flowPattern",
-    foreignKey: "foreignKey",
-    formPattern: "formPattern",
-    forwardedFrom: "forwardedFrom",
-    from: "from",
-    fs: "fs",
-    geometry: "geometry",
-    glob: "glob",
-    guard: "guard",
-    guards: "guards",
-    headers: "headers",
-    icon: "icon",
-    iconography: "iconography",
-    id: "id",
-    identity: "identity",
-    illustration: "illustration",
-    inbound: "inbound",
-    initialEffects: "initialEffects",
-    instances: "instances",
-    interactive: "interactive",
-    interval: "interval",
-    intrinsic: "intrinsic",
-    isFinal: "isFinal",
-    isInitial: "isInitial",
-    isTerminal: "isTerminal",
-    item: "item",
-    items: "items",
-    key: "key",
-    keyName: "keyName",
-    kind: "kind",
-    kinds: "kinds",
-    knob: "knob",
-    label: "label",
-    lazy: "lazy",
-    lazyPages: "lazyPages",
-    themeDefinitions: "themeDefinitions",
-    ledger: "ledger",
-    linkedEntity: "linkedEntity",
-    linkedEntityId: "linkedEntityId",
-    listPattern: "listPattern",
-    listened: "listened",
-    listens: "listens",
-    local: "local",
-    locales: "locales",
-    location: "location",
-    max: "max",
-    maxAttempts: "maxAttempts",
-    mergedFrom: "mergedFrom",
-    projectedFrom: "projectedFrom",
-    messageSources: "messageSources",
-    min: "min",
-    mock: "mock",
-    modes: "modes",
-    motion: "motion",
-    mounts: "mounts",
-    name: "name",
-    nestedForwardedFrom: "nestedForwardedFrom",
-    net: "net",
-    omit: "omit",
-    onDelete: "onDelete",
-    onEntry: "onEntry",
-    onExit: "onExit",
-    only: "only",
-    orbRef: "orbRef",
-    orbital: "orbital",
-    orbitalId: "orbitalId",
-    orbitals: "orbitals",
-    originalEvent: "originalEvent",
-    originalName: "originalName",
-    outbound: "outbound",
-    owner: "owner",
-    pageIds: "pageIds",
-    pages: "pages",
-    parent: "parent",
-    path: "path",
-    pattern: "pattern",
-    patternPath: "patternPath",
-    payload: "payload",
-    payloadEntity: "payloadEntity",
-    payloadFor: "payloadFor",
-    payloadMapping: "payloadMapping",
-    payloadSchema: "payloadSchema",
-    persistence: "persistence",
-    personas: "personas",
-    presentation: "presentation",
-    primaryColor: "primaryColor",
-    primaryEntity: "primaryEntity",
-    primaryKey: "primaryKey",
-    priority: "priority",
-    prop: "prop",
-    properties: "properties",
-    props: "props",
-    provides: "provides",
-    publicDir: "publicDir",
-    radii: "radii",
-    read: "read",
-    read_policy: "read_policy",
-    reconnect: "reconnect",
-    ref: "ref",
-    refId: "refId",
-    reference: "reference",
-    relatedLinks: "relatedLinks",
-    relation: "relation",
-    renames: "renames",
-    request: "request",
-    requestFragment: "requestFragment",
-    required: "required",
-    requiredFields: "requiredFields",
-    requires: "requires",
-    resolved: "resolved",
-    resource: "resource",
-    role: "role",
-    roles: "roles",
-    rows: "rows",
-    runsInBackground: "runsInBackground",
-    runtime: "runtime",
-    schemaVersion: "schemaVersion",
-    scope: "scope",
-    scopeOverridden: "scopeOverridden",
-    secretEnv: "secretEnv",
-    sections: "sections",
-    semanticRole: "semanticRole",
-    serverPath: "serverPath",
-    services: "services",
-    shadows: "shadows",
-    shape: "shape",
-    shared: "shared",
-    singleton: "singleton",
-    site: "site",
-    skeleton: "skeleton",
-    slot: "slot",
-    slots: "slots",
-    softDelete: "softDelete",
-    source: "source",
-    sourceBehavior: "sourceBehavior",
-    sourceDeclaration: "sourceDeclaration",
-    sourceEntityDefinition: "sourceEntityDefinition",
-    spacing: "spacing",
-    spec: "spec",
-    stack: "stack",
-    state: "state",
-    stateMachine: "stateMachine",
-    states: "states",
-    strict: "strict",
-    style: "style",
-    subDomain: "subDomain",
-    suggestedGuards: "suggestedGuards",
-    summary: "summary",
-    surface: "surface",
-    surfaces: "surfaces",
-    synonyms: "synonyms",
-    sys: "sys",
-    target: "target",
-    targetView: "targetView",
-    text: "text",
-    theme: "theme",
-    tick: "tick",
-    ticks: "ticks",
-    tier: "tier",
-    timeBoundMs: "timeBoundMs",
-    timeout: "timeout",
-    timestamps: "timestamps",
-    title: "title",
-    to: "to",
-    tokens: "tokens",
-    trait: "trait",
-    traitEmbedIds: "traitEmbedIds",
-    traitId: "traitId",
-    traitName: "traitName",
-    traitRefIds: "traitRefIds",
-    traits: "traits",
-    transition: "transition",
-    transitions: "transitions",
-    triggers: "triggers",
-    triggersId: "triggersId",
-    type: "type",
-    typeArgs: "typeArgs",
-    typeParams: "typeParams",
-    typeScale: "typeScale",
-    typeWhen: "typeWhen",
-    types: "types",
-    typography: "typography",
-    ui: "ui",
-    unique: "unique",
-    update: "update",
-    update_policy: "update_policy",
-    updatedAt: "updatedAt",
-    url: "url",
-    uses: "uses",
-    uxHints: "uxHints",
-    values: "values",
-    variant: "variant",
-    variants: "variants",
-    version: "version",
-    viewType: "viewType",
-    visual_prompt: "visual_prompt",
-    vocabulary: "vocabulary",
-    whileVisible: "whileVisible",
-    seedMock: "seedMock",
-    localeInstances: "localeInstances",
-    diagram: "diagram",
-    scene: "scene",
-    access: "access",
-    indexing: "indexing",
-    origin: "origin",
-    signIn: "signIn",
-    sourcePage: "sourcePage",
-    translationOf: "translationOf",
-    pageModifiers: "pageModifiers",
-    answers: "answers",
-    verifies: "verifies",
-    header: "header",
-    credential: "credential",
-    egress: "egress",
-    stdio: "stdio",
-    store: "store",
-    themes: "themes",
-    osGrants: "osGrants",
-    deployment: "deployment",
-    address: "address",
-    browser: "browser",
-    dispatch: "dispatch",
-    protocol: "protocol",
-    input: "input"
-  }
-};
-
-// src/i18n/lolo-lexer.ts
-var IDENT_START = /[\p{L}_]/u;
-var IDENT_CONTINUE = /[\p{L}\p{N}_/-]/u;
-var SIGIL_CONTINUE = /[\p{L}\p{N}_.]/u;
-var DIGIT = /[0-9]/;
-function lexLolo(source) {
-  const tokens = [];
-  let i = 0;
-  const n = source.length;
-  const push = (kind, start, end, text, textStart) => {
-    tokens.push({
-      kind,
-      start,
-      end,
-      text: text ?? source.slice(start, end),
-      textStart: textStart ?? start
-    });
-  };
-  while (i < n) {
-    const c = source[i];
-    if (c === " " || c === "	" || c === "\r" || c === "\n") {
-      i++;
-      continue;
-    }
-    if (c === "#") {
-      const start2 = i;
-      if (source[i + 1] === "=") {
-        const close = source.indexOf("=#", i + 2);
-        i = close === -1 ? n : close + 2;
-      } else {
-        const nl = source.indexOf("\n", i);
-        i = nl === -1 ? n : nl;
-      }
-      push("comment", start2, i);
-      continue;
-    }
-    if (c === ";" && source[i + 1] === ";") {
-      const start2 = i;
-      const nl = source.indexOf("\n", i);
-      i = nl === -1 ? n : nl;
-      push("comment", start2, i);
-      continue;
-    }
-    if (c === '"') {
-      const start2 = i;
-      i++;
-      while (i < n) {
-        if (source[i] === "\\") {
-          i += 2;
-          continue;
-        }
-        if (source[i] === '"') {
-          i++;
-          break;
-        }
-        i++;
-      }
-      push("string", start2, Math.min(i, n));
-      continue;
-    }
-    if (c === "@") {
-      const start2 = i;
-      i++;
-      if (source[i] === "(") {
-        i++;
-        push("punct", start2, i);
-        continue;
-      }
-      const nameStart = i;
-      while (i < n && SIGIL_CONTINUE.test(source[i])) i++;
-      push("sigil", start2, i, source.slice(nameStart, i), nameStart);
-      continue;
-    }
-    if (c === "?") {
-      const start2 = i;
-      i++;
-      if (i < n && IDENT_START.test(source[i])) {
-        const nameStart = i;
-        while (i < n && SIGIL_CONTINUE.test(source[i])) i++;
-        push("payload-sigil", start2, i, source.slice(nameStart, i), nameStart);
-      } else {
-        push("payload-sigil", start2, i, "", i);
-      }
-      continue;
-    }
-    if (c === "-") {
-      const start2 = i;
-      if (source[i + 1] === ">") {
-        i += 2;
-        push("punct", start2, i);
-      } else if (source[i + 1] === "-") {
-        i += 2;
-        push("punct", start2, i);
-      } else if (source[i + 1] !== void 0 && DIGIT.test(source[i + 1])) {
-        i++;
-        while (i < n && (DIGIT.test(source[i]) || source[i] === ".")) i++;
-        push("number", start2, i);
-      } else {
-        i++;
-        push("identifier", start2, i);
-      }
-      continue;
-    }
-    if (DIGIT.test(c)) {
-      const start2 = i;
-      while (i < n && (DIGIT.test(source[i]) || source[i] === ".")) i++;
-      push("number", start2, i);
-      continue;
-    }
-    if (c === "=" || c === "!" || c === "<" || c === ">") {
-      const start2 = i;
-      i++;
-      if (source[i] === "=") i++;
-      const two = i - start2 === 2;
-      push(two ? "identifier" : "punct", start2, i);
-      continue;
-    }
-    if (c === "+" || c === "*" || c === "/" || c === "%") {
-      const start2 = i;
-      i++;
-      push("identifier", start2, i);
-      continue;
-    }
-    if (IDENT_START.test(c)) {
-      const start2 = i;
-      while (i < n && IDENT_CONTINUE.test(source[i])) i++;
-      const text = source.slice(start2, i);
-      push(text === "true" || text === "false" || text === "null" ? "literal" : "identifier", start2, i, text);
-      continue;
-    }
-    const start = i;
-    i++;
-    if (c === ":" && source[i] === ":") i++;
-    push("punct", start, i);
-  }
-  return tokens;
-}
-
-// src/i18n/localize.ts
-var LOLO_SECTIONS = [
-  "keywords",
-  "shapes",
-  "tags",
-  "categories",
-  "capabilities",
-  "annotations",
-  "sigils",
-  "effects",
-  "types",
-  "units",
-  "literals",
-  "reservedEvents"
-];
-var CANON_ANY_ORDER = [
-  "keywords",
-  "shapes",
-  "tags",
-  "categories",
-  "capabilities",
-  "annotations",
-  "sigils",
-  "types",
-  "units",
-  "literals",
-  "reservedEvents"
-];
-function forward(lang, sections, resolutionOrder, operators) {
-  const canon = (native) => {
-    for (const section of resolutionOrder) {
-      for (const [english, value] of Object.entries(getVocabulary(lang)[section])) {
-        if (value === native) return english;
-      }
-    }
-    if (operators) {
-      for (const [english, value] of Object.entries(operators.operators)) {
-        if (value === native) return english;
-      }
-    }
-    return void 0;
-  };
-  const map = /* @__PURE__ */ new Map();
-  const add = (english, native) => {
-    if (canon(native) !== english) return;
-    map.set(english, native);
-  };
-  for (const section of sections) {
-    for (const [english, native] of Object.entries(getVocabulary(lang)[section])) {
-      add(english, native);
-    }
-  }
-  if (operators) {
-    for (const [english, native] of Object.entries(operators.operators)) {
-      add(english, native);
-    }
-  }
-  return map;
-}
-function localizeMap(lang, operators) {
-  return forward(lang, LOLO_SECTIONS, CANON_ANY_ORDER, operators);
-}
-function isWordShaped(english) {
-  return /^[A-Za-z_][A-Za-z0-9_/-]*$/.test(english);
-}
-var FIELD_BLOCK_HEADS = /* @__PURE__ */ new Set(["entity", "type", "config", "params", "variants", "tokens", "event"]);
-var EVENT_BLOCK_HEADS = /* @__PURE__ */ new Set(["listens", "emits", "events"]);
-var NAME_INTRODUCING = /* @__PURE__ */ new Set([
-  "app",
-  "orbital",
-  "entity",
-  "trait",
-  "state",
-  "page",
-  "type",
-  "event",
-  "uses",
-  "theme",
-  "as",
-  "extend"
-]);
-var NAME_PUNCT = /* @__PURE__ */ new Set(["->", "-->", "\u2192", ".", "--"]);
-function localizeLoloSource(source, lang, options = {}) {
-  if (lang === "en") return source;
-  const { operators } = options;
-  const keywords = forward(lang, ["keywords"], CANON_ANY_ORDER);
-  const shapes = forward(lang, ["shapes"], CANON_ANY_ORDER);
-  const types = forward(lang, ["types"], ["types"]);
-  const modifiers = forward(lang, ["tags", "categories", "capabilities", "keywords"], CANON_ANY_ORDER);
-  const heads = forward(lang, ["effects"], ["effects"], operators);
-  const sigils = forward(lang, ["sigils", "annotations"], ["sigils", "annotations"]);
-  const bindingSigils = forward(lang, ["sigils"], ["sigils", "annotations"]);
-  const literals = forward(lang, ["literals"], ["literals"]);
-  const units = forward(lang, ["units"], ["units"]);
-  const reservedEvents = forward(lang, ["reservedEvents"], ["reservedEvents"]);
-  const tokens = lexLolo(source);
-  const edits = [];
-  const stack = [
-    {
-      kind: "root",
-      stmtHead: void 0,
-      blockHead: void 0,
-      afterColon: false,
-      sawEquals: false,
-      refBody: false,
-      parenHead: void 0,
-      binderSeen: false
-    }
-  ];
-  const top = () => stack[stack.length - 1];
-  let prev;
-  const replace = (token, map) => {
-    if (!isWordShaped(token.text)) return;
-    const native = map.get(token.text);
-    if (native === void 0 || native === token.text) return;
-    edits.push({ start: token.textStart, end: token.end, text: native });
-  };
-  for (let index = 0; index < tokens.length; index++) {
-    const token = tokens[index];
-    if (token.kind === "comment") continue;
-    const frame = top();
-    const startsStatement = prev === void 0 || prev.text === "{" || prev.text === "}" || source.slice(prev.end, token.start).includes("\n");
-    if (startsStatement) {
-      frame.stmtHead = void 0;
-      frame.afterColon = false;
-      frame.sawEquals = false;
-    }
-    if (token.kind === "punct") {
-      const text = source.slice(token.start, token.end);
-      const child = (kind) => ({
-        kind,
-        stmtHead: void 0,
-        blockHead: frame.stmtHead,
-        afterColon: false,
-        sawEquals: false,
-        refBody: frame.refBody || frame.sawEquals,
-        parenHead: void 0,
-        binderSeen: false
-      });
-      if (text === "(" || text === "@(") {
-        stack.push({ ...child(parenFrame(frame, prev)), blockHead: void 0 });
-        if (top().kind === "binder-list") frame.binderSeen = true;
-      } else if (text === "{") {
-        stack.push(child(braceFrame(frame, prev)));
-      } else if (text === "[") {
-        stack.push(child(bracketFrame(frame, prev)));
-      } else if (text === ")" || text === "}" || text === "]") {
-        if (stack.length > 1) stack.pop();
-        top().afterColon = false;
-        top().sawEquals = false;
-      } else if (text === ":") {
-        frame.afterColon = true;
-      } else if (text === "=") {
-        frame.afterColon = false;
-        frame.sawEquals = true;
-      } else if (text === ",") {
-        frame.afterColon = false;
-        frame.sawEquals = false;
-        frame.stmtHead = void 0;
-      }
-      prev = token;
-      continue;
-    }
-    const opaque = frame.kind === "object" || frame.kind === "array" || frame.kind === "binder-list" || frame.kind === "binder-pair" && prev !== void 0 && prev.text === "(";
-    if (token.kind === "sigil") {
-      const dot = token.text.indexOf(".");
-      const root = dot === -1 ? token.text : token.text.slice(0, dot);
-      const native = (opaque || frame.kind === "paren" ? bindingSigils : sigils).get(root);
-      if (native !== void 0 && native !== root) {
-        edits.push({ start: token.textStart, end: token.textStart + root.length, text: native });
-      }
-      prev = token;
-      continue;
-    }
-    if (token.kind === "payload-sigil" || token.kind === "string" || token.kind === "number") {
-      prev = token;
-      continue;
-    }
-    if (token.kind === "literal") {
-      if (!opaque) replace(token, literals);
-      prev = token;
-      continue;
-    }
-    const prevText = prev === void 0 ? void 0 : source.slice(prev.start, prev.end);
-    const afterName = prevText !== void 0 && (NAME_INTRODUCING.has(prevText) || NAME_PUNCT.has(prevText));
-    if (token.text === "INIT" && !opaque && !frame.sawEquals) {
-      replace(token, reservedEvents);
-      if (frame.stmtHead === void 0) frame.stmtHead = token.text;
-      prev = token;
-      continue;
-    }
-    if (!opaque && !startsStatement && prev !== void 0 && prev.kind === "number") {
-      replace(token, units);
-      prev = token;
-      continue;
-    }
-    switch (frame.kind) {
-      case "paren": {
-        if (prevText === "(") {
-          frame.parenHead = token.text;
-          replace(token, heads);
-        }
-        break;
-      }
-      case "binder-list":
-      case "binder-pair":
-        break;
-      case "object":
-      case "array":
-        break;
-      case "mods":
-        if (!frame.afterColon) replace(token, modifiers);
-        break;
-      case "type-array":
-        replace(token, types);
-        break;
-      case "block-fields": {
-        if (frame.afterColon && !afterName) replace(token, types);
-        break;
-      }
-      case "root":
-      case "block-body": {
-        if (!afterName) replace(token, frame.afterColon ? types : keywords);
-        break;
-      }
-    }
-    if ((frame.kind === "root" || frame.kind === "block-body") && prevText === "=") {
-      replace(token, shapes);
-    }
-    if (frame.stmtHead === void 0) frame.stmtHead = token.text;
-    prev = token;
-  }
-  return applyEdits(source, edits);
-}
-function parenFrame(frame, prev) {
-  if (frame.kind === "binder-list") return "binder-pair";
-  if (frame.kind === "paren" && !frame.binderSeen && prev !== void 0 && prev.text === frame.parenHead && (frame.parenHead === "let" || frame.parenHead === "fn" || frame.parenHead === "lambda")) {
-    return "binder-list";
-  }
-  return "paren";
-}
-function braceFrame(frame, prev) {
-  if (isExpression(frame.kind)) return "object";
-  if (frame.kind === "block-fields" && prev !== void 0 && prev.text === "=") return "object";
-  if (frame.refBody && frame.stmtHead === "config") return "object";
-  if (frame.blockHead !== void 0 && EVENT_BLOCK_HEADS.has(frame.blockHead)) return "block-fields";
-  if (frame.kind === "type-array") return "block-fields";
-  if (frame.kind === "block-fields" && frame.afterColon) return "block-fields";
-  const head = frame.stmtHead;
-  return head !== void 0 && FIELD_BLOCK_HEADS.has(head) ? "block-fields" : "block-body";
-}
-function bracketFrame(frame, prev) {
-  if (isExpression(frame.kind)) return "array";
-  if (prev !== void 0 && prev.text === "=") return "array";
-  if (frame.afterColon) return frame.kind === "block-fields" ? "type-array" : "array";
-  return "mods";
-}
-function isExpression(kind) {
-  return kind === "paren" || kind === "object" || kind === "array" || kind === "binder-list" || kind === "binder-pair";
-}
-function applyEdits(source, edits) {
-  if (edits.length === 0) return source;
-  edits.sort((a, b) => a.start - b.start);
-  let out = "";
-  let cursor = 0;
-  for (const edit of edits) {
-    if (edit.start < cursor) continue;
-    out += source.slice(cursor, edit.start) + edit.text;
-    cursor = edit.end;
-  }
-  return out + source.slice(cursor);
-}
-function localizeOrbValue(value, lang, options = {}) {
-  if (lang === "en") return value;
-  const orbKeys = forward(lang, ["orb"], ["orb"]);
-  const types = forward(lang, ["types"], ["types"]);
-  const tags = forward(lang, ["tags"], ["tags"]);
-  const heads = forward(lang, ["effects"], ["effects"], options.operators);
-  const sigils = forward(lang, ["sigils"], ["sigils", "annotations"]);
-  const walk = (node, inExpression) => {
-    if (Array.isArray(node)) {
-      const head = node[0];
-      const native = typeof head === "string" ? heads.get(head) : void 0;
-      const isExpression2 = native !== void 0;
-      const items = node.map(
-        (child, index) => index === 0 && isExpression2 ? child : walk(child, inExpression || isExpression2)
-      );
-      if (native !== void 0) items[0] = native;
-      return items;
-    }
-    if (node !== null && typeof node === "object") {
-      const out = {};
-      for (const [key, child] of Object.entries(node)) {
-        const nativeKey = orbKeys.get(key) ?? key;
-        let next = walk(child, inExpression);
-        if (typeof next === "string") {
-          if (key === "type" && !inExpression) next = types.get(next) ?? next;
-          else if (key === "persistence") next = tags.get(next) ?? next;
-        }
-        out[nativeKey] = next;
-      }
-      return out;
-    }
-    if (typeof node === "string" && node.startsWith("@")) {
-      const rest = node.slice(1);
-      const dot = rest.indexOf(".");
-      const root = dot === -1 ? rest : rest.slice(0, dot);
-      const native = sigils.get(root);
-      if (native === void 0) return node;
-      return dot === -1 ? `@${native}` : `@${native}${rest.slice(dot)}`;
-    }
-    return node;
-  };
-  return walk(value, false);
-}
-
-// src/i18n/index.ts
-var RTL_LOCALES = ["ar", "he", "fa", "ur"];
-function localeDirection(locale) {
-  return RTL_LOCALES.includes(locale) ? "rtl" : "ltr";
-}
-function pathLocale(path, locales) {
-  const first = path.replace(/^\/+/, "").split("/")[0] ?? "";
-  return locales.find((l) => l === first);
-}
-function localeOfPath(path, locales) {
-  return pathLocale(path, locales) ?? locales[0];
-}
-function localeAlternates(pages, page, locales) {
-  const indexable = (p) => p.access === "public" && p.indexing !== "noindex";
-  const group = (p) => p.translationOf ?? p.sourcePage;
-  const key = group(page);
-  if (!indexable(page) || key === void 0) return void 0;
-  const byLocale = [];
-  for (const other of pages) {
-    if (group(other) !== key || !indexable(other)) continue;
-    const locale = localeOfPath(other.path, locales);
-    if (locale === void 0 || byLocale.some((a) => a.locale === locale)) return void 0;
-    byLocale.push({ locale, path: other.path });
-  }
-  if (byLocale.length < 2) return void 0;
-  return byLocale.sort((a, b) => locales.indexOf(a.locale) - locales.indexOf(b.locale));
-}
-var I18N_SECTIONS = [
-  "keywords",
-  "shapes",
-  "tags",
-  "categories",
-  "capabilities",
-  "annotations",
-  "sigils",
-  "effects",
-  "types",
-  "units",
-  "literals",
-  "reservedEvents",
-  "orb"
-];
-function isPlainObject(x) {
-  return typeof x === "object" && x !== null && !Array.isArray(x);
-}
-function isRawI18nTable(x) {
-  return isPlainObject(x);
-}
-function isStringRecord(x) {
-  if (!isPlainObject(x)) return false;
-  for (const value of Object.values(x)) {
-    if (typeof value !== "string") return false;
-  }
-  return true;
-}
-var LANGUAGE_CODE = /^[a-z]{2,3}(-[A-Za-z0-9]{2,8})*$/;
-function isLanguageCode(x) {
-  return typeof x === "string" && LANGUAGE_CODE.test(x);
-}
-function isI18nMeta(x) {
-  if (!isPlainObject(x) || !("code" in x) || !("name" in x) || !("rtl" in x)) return false;
-  return isLanguageCode(x.code) && typeof x.name === "string" && typeof x.rtl === "boolean";
-}
-function emptySections() {
-  return {
-    keywords: {},
-    shapes: {},
-    tags: {},
-    categories: {},
-    capabilities: {},
-    annotations: {},
-    sigils: {},
-    effects: {},
-    types: {},
-    units: {},
-    literals: {},
-    reservedEvents: {},
-    orb: {}
-  };
-}
-function parseI18nTables(raw, source) {
-  if (!isRawI18nTable(raw)) {
-    throw new Error(`i18n table "${source}": expected a JSON object, got ${typeof raw}`);
-  }
-  if (!isI18nMeta(raw.meta)) {
-    throw new Error(`i18n table "${source}": missing or malformed "meta" (expected { code, name, rtl })`);
-  }
-  const badSections = [];
-  const sections = emptySections();
-  for (const section of I18N_SECTIONS) {
-    const value = raw[section];
-    if (value === void 0) continue;
-    if (!isStringRecord(value)) {
-      badSections.push(section);
-      continue;
-    }
-    sections[section] = value;
-  }
-  if (badSections.length > 0) {
-    throw new Error(`i18n table "${source}": sections not Record<string,string>: ${badSections.join(", ")}`);
-  }
-  return { meta: raw.meta, ...sections };
-}
-function parseNotationKeys(raw, source) {
-  if (!isPlainObject(raw) || !("keys" in raw) || !Array.isArray(raw.keys)) {
-    throw new Error(`notation file "${source}": expected { keys: string[] }`);
-  }
-  const keys = [];
-  for (const key of raw.keys) {
-    if (typeof key !== "string") {
-      throw new Error(`notation file "${source}": every key must be a string`);
-    }
-    keys.push(key);
-  }
-  return keys;
-}
-function parseOperatorTables(raw, source) {
-  if (!isPlainObject(raw) || !("operators" in raw) || !isStringRecord(raw.operators)) {
-    throw new Error(`operator table "${source}": expected { operators: Record<string,string> }`);
-  }
-  return { operators: raw.operators };
-}
-var ORB_NOTATION_KEYS = new Set(
-  parseNotationKeys(orb_notation_default, "orb-notation.json")
-);
-var englishTables = parseI18nTables(en_default, "en.json");
-function parseVocabularyPack(raw, source) {
-  const tables = parseI18nTables(raw, source);
-  const { operators } = parseOperatorTables(raw, source);
-  return { ...tables, operators };
-}
-var registeredPacks = /* @__PURE__ */ new Map();
-var FATAL_PACK_PROBLEMS = /* @__PURE__ */ new Set(["collision", "selector-not-unique", "inconsistent", "empty"]);
-function registerVocabulary(pack) {
-  const code = pack.meta.code;
-  if (code === "en") throw new Error('language pack "en": English is built in and cannot be replaced');
-  const existing = registeredPacks.get(code);
-  if (existing) {
-    if (JSON.stringify(existing) === JSON.stringify(pack)) return;
-    throw new Error(`language pack "${code}": a different "${code}" pack is already installed`);
-  }
-  const core = { en: englishTables };
-  for (const [other, table] of registeredPacks) core[other] = table;
-  core[code] = pack;
-  const std = {};
-  for (const [other, table] of registeredPacks) std[other] = { operators: table.operators };
-  std[code] = { operators: pack.operators };
-  const fatal = checkI18nCoverage({ core, std }).problems.filter((p) => p.lang === code && FATAL_PACK_PROBLEMS.has(p.kind));
-  if (fatal.length > 0) {
-    const lines = fatal.map((p) => `${p.kind} ${p.section}.${p.key}${p.detail ? ` \u2014 ${p.detail}` : ""}`);
-    throw new Error(`language pack "${code}" is refused:
-  ${lines.join("\n  ")}`);
-  }
-  registeredPacks.set(code, pack);
-}
-function installedLanguages() {
-  return ["en", ...[...registeredPacks.keys()].sort()];
-}
-function getVocabulary(lang) {
-  if (lang === "en") return englishTables;
-  const pack = registeredPacks.get(lang);
-  if (!pack) {
-    throw new Error(`language "${lang}" is not installed \u2014 install its language pack (\`orb language install <package>\`) and register it`);
-  }
-  return pack;
-}
-function vocabularyOperators(lang) {
-  const pack = registeredPacks.get(lang);
-  return pack ? { operators: pack.operators } : void 0;
-}
-function aliasMap(lang, section, operators) {
-  let table;
-  if (section === "operators") {
-    if (!operators) {
-      throw new Error(`aliasMap("${lang}", "operators") requires an OperatorTables argument`);
-    }
-    table = operators.operators;
-  } else {
-    table = getVocabulary(lang)[section];
-  }
-  const map = /* @__PURE__ */ new Map();
-  for (const [english, native] of Object.entries(table)) {
-    map.set(native, english);
-  }
-  return map;
-}
-var LOLO_FIRST_TOKEN_KEYWORDS = ["app", "uses", "expects", "type", "theme", "orbital"];
-function languageOfLoloFirstToken(token) {
-  const matches = installedLanguages().filter(
-    (lang) => LOLO_FIRST_TOKEN_KEYWORDS.some((kw) => getVocabulary(lang).keywords[kw] === token)
-  );
-  return matches.length === 1 ? matches[0] : void 0;
-}
-function languageOfOrbTopLevelKeys(keys) {
-  const keySet = new Set(keys);
-  const matches = installedLanguages().filter((lang) => keySet.has(getVocabulary(lang).orb.orbitals));
-  return matches.length === 1 ? matches[0] : void 0;
-}
-function checkI18nCoverage(input) {
-  const problems = [];
-  const { core, std, canonicalOperators } = input;
-  const enTable = core.en;
-  for (const lang of Object.keys(core)) {
-    for (const key of Object.keys(core[lang].orb)) {
-      if (ORB_NOTATION_KEYS.has(key)) {
-        problems.push({
-          lang,
-          section: "orb",
-          kind: "notation-in-vocabulary",
-          key,
-          detail: "design-system token name \u2014 notation, not language vocabulary"
-        });
-      }
-    }
-  }
-  for (const lang of Object.keys(core)) {
-    const table = core[lang];
-    for (const section of I18N_SECTIONS) {
-      const values = table[section];
-      if (lang !== "en") {
-        const enKeys = new Set(Object.keys(enTable[section]));
-        const langKeys = new Set(Object.keys(values));
-        for (const key of enKeys) {
-          if (!langKeys.has(key)) {
-            problems.push({ lang, section, kind: "missing", key });
-          }
-        }
-        for (const key of langKeys) {
-          if (!enKeys.has(key)) {
-            problems.push({ lang, section, kind: "orphan", key });
-          }
-        }
-      }
-      for (const [key, value] of Object.entries(values)) {
-        if (value === "") {
-          problems.push({ lang, section, kind: "empty", key });
-        }
-      }
-    }
-  }
-  for (const lang of Object.keys(core)) {
-    const table = core[lang];
-    const occurrences = /* @__PURE__ */ new Map();
-    for (const section of I18N_SECTIONS) {
-      for (const [key, value] of Object.entries(table[section])) {
-        const list = occurrences.get(key) ?? [];
-        list.push({ section, value });
-        occurrences.set(key, list);
-      }
-    }
-    const opTable = std?.[lang]?.operators;
-    if (opTable) {
-      for (const [key, value] of Object.entries(opTable)) {
-        const list = occurrences.get(key) ?? [];
-        list.push({ section: "operators", value });
-        occurrences.set(key, list);
-      }
-    }
-    for (const [key, entries] of occurrences) {
-      if (entries.length < 2) continue;
-      const baseline = entries[0];
-      for (let i = 1; i < entries.length; i++) {
-        const entry = entries[i];
-        if (entry.value !== baseline.value) {
-          problems.push({
-            lang,
-            section: entry.section,
-            kind: "inconsistent",
-            key,
-            detail: `"${key}" is "${baseline.value}" in ${baseline.section} but "${entry.value}" in ${entry.section}`
-          });
-        }
-      }
-    }
-  }
-  for (const lang of Object.keys(core)) {
-    const table = core[lang];
-    for (const section of I18N_SECTIONS) {
-      const byValue = /* @__PURE__ */ new Map();
-      for (const [key, value] of Object.entries(table[section])) {
-        const keys = byValue.get(value) ?? [];
-        keys.push(key);
-        byValue.set(value, keys);
-      }
-      for (const [value, keys] of byValue) {
-        if (keys.length < 2) continue;
-        for (let i = 1; i < keys.length; i++) {
-          problems.push({
-            lang,
-            section,
-            kind: "collision",
-            key: keys[i],
-            detail: `shares native value "${value}" with "${keys[0]}" in ${section}`
-          });
-        }
-      }
-    }
-    const combined = /* @__PURE__ */ new Map();
-    for (const [key, value] of Object.entries(table.effects)) {
-      const list = combined.get(value) ?? [];
-      list.push({ section: "effects", key });
-      combined.set(value, list);
-    }
-    const opTable = std?.[lang]?.operators;
-    if (opTable) {
-      for (const [key, value] of Object.entries(opTable)) {
-        const list = combined.get(value) ?? [];
-        list.push({ section: "operators", key });
-        combined.set(value, list);
-      }
-    }
-    for (const [value, entries] of combined) {
-      const hasEffects = entries.some((e) => e.section === "effects");
-      const hasOperators = entries.some((e) => e.section === "operators");
-      if (!(hasEffects && hasOperators)) continue;
-      const first = entries[0];
-      for (const entry of entries.slice(1)) {
-        if (entry.key === first.key) continue;
-        problems.push({
-          lang,
-          section: "effects\u222Aoperators",
-          kind: "collision",
-          key: entry.key,
-          detail: `shares native value "${value}" with "${first.key}" (${first.section}) in effects\u222Aoperators`
-        });
-      }
-    }
-  }
-  const selectorUses = /* @__PURE__ */ new Map();
-  for (const lang of Object.keys(core)) {
-    const table = core[lang];
-    const selectors = [
-      ...LOLO_FIRST_TOKEN_KEYWORDS.map((key) => ({ section: "keywords", key, value: table.keywords[key] })),
-      { section: "orb", key: "orbitals", value: table.orb.orbitals }
-    ];
-    for (const { section, key, value } of selectors) {
-      if (value === void 0) continue;
-      const uses = selectorUses.get(value) ?? [];
-      uses.push({ lang, section, key });
-      selectorUses.set(value, uses);
-    }
-  }
-  for (const [value, uses] of selectorUses) {
-    const langs = new Set(uses.map((u) => u.lang));
-    if (langs.size < 2) continue;
-    for (const use of uses) {
-      const others = uses.filter((u) => u.lang !== use.lang).map((u) => `${u.lang}:${u.section}.${u.key}`);
-      problems.push({
-        lang: use.lang,
-        section: use.section,
-        kind: "selector-not-unique",
-        key: use.key,
-        detail: `${use.section}.${use.key} = "${value}" is also a language selector in: ${others.join(", ")}`
-      });
-    }
-  }
-  if (std && canonicalOperators) {
-    const canonicalSet = new Set(canonicalOperators);
-    for (const lang of Object.keys(core)) {
-      const opTable = std[lang]?.operators;
-      if (!opTable) continue;
-      const langKeys = new Set(Object.keys(opTable));
-      for (const op of canonicalSet) {
-        if (!langKeys.has(op)) {
-          problems.push({ lang, section: "operators", kind: "operators-mismatch", key: op, detail: "missing from language operator table" });
-        }
-      }
-      for (const op of langKeys) {
-        if (!canonicalSet.has(op)) {
-          problems.push({ lang, section: "operators", kind: "operators-mismatch", key: op, detail: "not present in canonical operator set" });
-        }
-      }
-    }
-  }
-  return { ok: problems.length === 0, problems };
-}
-function reportIdenticalToEnglish(input) {
-  const problems = [];
-  const enTable = input.core.en;
-  for (const lang of Object.keys(input.core)) {
-    if (lang === "en") continue;
-    const table = input.core[lang];
-    for (const section of I18N_SECTIONS) {
-      for (const [key, value] of Object.entries(table[section])) {
-        const enValue = enTable[section][key];
-        if (enValue !== void 0 && value === enValue) {
-          problems.push({ lang, section, kind: "identical-to-english", key, detail: `matches English value "${enValue}"` });
-        }
-      }
-    }
-  }
-  return problems;
-}
-
-export { I18N_SECTIONS, LOLO_FIRST_TOKEN_KEYWORDS, ORB_NOTATION_KEYS, RTL_LOCALES, aliasMap, checkI18nCoverage, englishTables, getVocabulary, installedLanguages, languageOfLoloFirstToken, languageOfOrbTopLevelKeys, lexLolo, localeAlternates, localeDirection, localeOfPath, localizeLoloSource, localizeMap, localizeOrbValue, parseI18nTables, parseOperatorTables, parseVocabularyPack, pathLocale, registerVocabulary, reportIdenticalToEnglish, vocabularyOperators };
-//# sourceMappingURL=chunk-JOHDVS6J.js.map
-//# sourceMappingURL=chunk-JOHDVS6J.js.map