@terrafirmagreg-team/dump 0.0.0-stage → 1.2.0

package/package.json

@@ -1,6 +1,31 @@
 {
   "name": "@terrafirmagreg-team/dump",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.2.0",
+  "type": "module",
+  "description": "Game-dump readers and contracts",
+  "license": "LGPL-3.0-only",
+  "exports": {
+    "./lib/*": [
+      "./src/lib/*.ts",
+      "./src/lib/*/index.ts"
+    ]
+  },
+  "files": [
+    "src"
+  ],
+  "dependencies": {
+    "@terrafirmagreg-team/data": "1.2.0",
+    "@terrafirmagreg-team/sites": "1.2.0",
+    "@terrafirmagreg-team/translate": "1.2.0",
+    "aws4fetch": "^1.0.20",
+    "fumadocs-core": "16.17.8"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TerraFirmaGreg-Team/Web-Foundation.git",
+    "directory": "packages/dump"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
 }

package/src/lib/dump/assets/atlas/dto.ts

@@ -0,0 +1,51 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+import type { DumpNbt, TaggedReference } from '@terrafirmagreg-team/dump/lib/dump/contract/ref';
+
+export type AtlasPage = {
+  image: string;
+  w: number;
+  h: number;
+};
+
+export type AtlasTint = 'none' | 'grass' | 'foliage' | 'water' | 'custom';
+
+export type AtlasSprite = {
+  ref: TaggedReference;
+  page: number;
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+  tint?: AtlasTint;
+  tintColor?: string;
+  langKey?: string;
+};
+
+export type AtlasKind = 'item' | 'block';
+
+export type IconAtlas = {
+  sprites: AtlasSprite[];
+  pages: AtlasPage[];
+  modId: string;
+  dataset: DatasetRef;
+  kind: AtlasKind;
+};
+
+export type AtlasBundle = {
+  items: IconAtlas | null;
+  blocks: IconAtlas | null;
+};
+
+export type SpriteQuery = {
+  kind?: 'item' | 'block' | 'fluid';
+  id: string;
+  tag?: DumpNbt;
+};
+
+export type AtlasLookup = {
+  atlas: IconAtlas;
+  sprite: AtlasSprite;
+  page: AtlasPage;
+  spriteId: string;
+};
+

package/src/lib/dump/assets/atlas/lookup.ts

@@ -0,0 +1,207 @@
+import type {
+  AtlasLookup,
+  AtlasSprite,
+  IconAtlas,
+  SpriteQuery,
+} from '@terrafirmagreg-team/dump/lib/dump/assets/atlas/dto';
+import {
+  asTaggedReference,
+  nbtSpecificity,
+  parseStackId,
+} from '@terrafirmagreg-team/dump/lib/dump/contract/ref';
+import type { DumpNbt, TaggedReference } from '@terrafirmagreg-team/dump/lib/dump/contract/ref';
+import { formatNbt } from '@terrafirmagreg-team/dump/lib/snbt';
+
+export { atlasPagePublicUrl } from '@terrafirmagreg-team/dump/lib/dump/assets/urls';
+
+function asStackKind(
+  kind: string | undefined,
+): SpriteQuery['kind'] | undefined {
+  return kind === 'item' || kind === 'block' || kind === 'fluid' ? kind : undefined;
+}
+
+function asSpriteQuery(
+  value: string | TaggedReference | SpriteQuery | null | undefined,
+  kind?: SpriteQuery['kind'],
+): SpriteQuery | null {
+  if (value == null) return null;
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    if (!trimmed) return null;
+    const parsed = parseStackId(trimmed);
+    if (!parsed.id) return null;
+    return {
+      id: parsed.id,
+      ...(kind ? { kind } : {}),
+      ...(parsed.nbt !== undefined ? { tag: parsed.nbt } : {}),
+    };
+  }
+  const tagged = asTaggedReference(value);
+  if (tagged) {
+    const stackKind = asStackKind(tagged.kind);
+    if (!stackKind) return null;
+    return {
+      kind: kind ?? stackKind,
+      id: tagged.id,
+      ...(tagged.tag !== undefined ? { tag: tagged.tag } : {}),
+    };
+  }
+  if (typeof value === 'object' && typeof value.id === 'string' && value.id) {
+    const resolvedKind = kind ?? asStackKind(value.kind);
+    return {
+      id: value.id,
+      ...(resolvedKind ? { kind: resolvedKind } : {}),
+      ...(value.tag !== undefined ? { tag: value.tag } : {}),
+    };
+  }
+  return null;
+}
+
+function spriteScore(
+  ref: TaggedReference,
+  query: SpriteQuery,
+  preferVariant: boolean,
+): number {
+  if (ref.id !== query.id) return -1;
+  if (query.kind && ref.kind !== query.kind) return -1;
+  if (query.tag === undefined) {
+    if (ref.tag === undefined) return 500;
+    return preferVariant ? 600 : -1;
+  }
+  if (ref.tag === undefined) return 100;
+  return nbtSpecificity(ref.tag, query.tag);
+}
+
+type SpriteBucket = {
+  all: AtlasSprite[];
+  untagged: AtlasSprite[];
+  tagged: AtlasSprite[];
+  byTag: Map<string, AtlasSprite[]>;
+  maxTagKeys: number;
+};
+
+const atlasIndex = new WeakMap<IconAtlas, Map<string, SpriteBucket>>();
+
+const EXACT_SAFE_MAX_KEYS = 99;
+
+function nbtTopKeys(tag: DumpNbt | undefined): number {
+  return tag !== null && typeof tag === 'object' && !Array.isArray(tag)
+    ? Object.keys(tag ?? {}).length
+    : 0;
+}
+
+function spriteBuckets(atlas: IconAtlas): Map<string, SpriteBucket> {
+  let byId = atlasIndex.get(atlas);
+  if (byId) return byId;
+  byId = new Map();
+  for (const sprite of atlas.sprites) {
+    const bucket =
+      byId.get(sprite.ref.id) ??
+      (() => {
+        const created: SpriteBucket = {
+          all: [],
+          untagged: [],
+          tagged: [],
+          byTag: new Map(),
+          maxTagKeys: 0,
+        };
+        byId.set(sprite.ref.id, created);
+        return created;
+      })();
+    bucket.all.push(sprite);
+    if (sprite.ref.tag === undefined) {
+      bucket.untagged.push(sprite);
+      continue;
+    }
+    bucket.tagged.push(sprite);
+    const keyCount = nbtTopKeys(sprite.ref.tag);
+    if (keyCount > bucket.maxTagKeys) bucket.maxTagKeys = keyCount;
+    const key = formatNbt(sprite.ref.tag);
+    if (key !== undefined) {
+      const list = bucket.byTag.get(key);
+      if (list) list.push(sprite);
+      else bucket.byTag.set(key, [sprite]);
+    }
+  }
+  atlasIndex.set(atlas, byId);
+  return byId;
+}
+
+function spriteHit(
+  atlas: IconAtlas,
+  sprite: AtlasSprite,
+): AtlasLookup | null {
+  const page = atlas.pages[sprite.page];
+  return page ? { atlas, sprite, page, spriteId: sprite.ref.id } : null;
+}
+
+function lookupSprite(
+  atlas: IconAtlas | null | undefined,
+  query?: string | TaggedReference | SpriteQuery | null,
+  kind?: SpriteQuery['kind'],
+  preferVariant = false,
+): AtlasLookup | null {
+  if (!atlas || query == null) return null;
+  const resolved = asSpriteQuery(query, kind);
+  if (!resolved) return null;
+  const bucket = spriteBuckets(atlas).get(resolved.id);
+  if (!bucket) return null;
+  if (resolved.tag === undefined) {
+    const first = preferVariant ? bucket.tagged : bucket.untagged;
+    const second = preferVariant ? bucket.untagged : bucket.tagged;
+    for (const list of [first, second]) {
+      for (const sprite of list) {
+        if (resolved.kind && sprite.ref.kind !== resolved.kind) continue;
+        const hit = spriteHit(atlas, sprite);
+        if (hit) return hit;
+      }
+    }
+    return null;
+  }
+  if (bucket.maxTagKeys <= EXACT_SAFE_MAX_KEYS) {
+    const exacts = bucket.byTag.get(formatNbt(resolved.tag) ?? '');
+    if (exacts) {
+      for (const sprite of exacts) {
+        if (resolved.kind && sprite.ref.kind !== resolved.kind) continue;
+        const hit = spriteHit(atlas, sprite);
+        if (hit) return hit;
+      }
+    }
+  }
+  let best: AtlasLookup | null = null;
+  let bestScore = -1;
+  for (const sprite of bucket.all) {
+    const score = spriteScore(sprite.ref, resolved, preferVariant);
+    if (score <= bestScore) continue;
+    const hit = spriteHit(atlas, sprite);
+    if (!hit) continue;
+    best = hit;
+    bestScore = score;
+  }
+  return best;
+}
+
+export function lookupSpriteInBundle(
+  bundle: { items: IconAtlas | null; blocks: IconAtlas | null } | null | undefined,
+  query?: string | TaggedReference | SpriteQuery | null,
+  kind?: SpriteQuery['kind'],
+  preferVariant = false,
+): AtlasLookup | null {
+  if (!bundle) return null;
+  const resolved = asSpriteQuery(query, kind);
+  if (!resolved) return null;
+  if (resolved.kind === 'block') {
+    return (
+      lookupSprite(bundle.blocks, resolved, undefined, preferVariant) ??
+      lookupSprite(bundle.items, resolved, undefined, preferVariant)
+    );
+  }
+  if (resolved.kind === 'item' || resolved.kind === 'fluid') {
+    return lookupSprite(bundle.items, resolved, undefined, preferVariant);
+  }
+  return (
+    lookupSprite(bundle.items, resolved, undefined, preferVariant) ??
+    lookupSprite(bundle.blocks, resolved, undefined, preferVariant)
+  );
+}
+

package/src/lib/dump/assets/atlas/sprites.ts

@@ -0,0 +1,132 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+import { asSpriteEntry } from '@terrafirmagreg-team/dump/lib/dump/data/registry/parse';
+import { asDisplay } from '@terrafirmagreg-team/dump/lib/dump/contract/text';
+import { asNbt } from '@terrafirmagreg-team/dump/lib/dump/contract/ref';
+import { asRecord, asString } from '@terrafirmagreg-team/dump/lib/dump/contract/read';
+import type {
+  AtlasKind,
+  AtlasTint,
+  IconAtlas,
+} from '@terrafirmagreg-team/dump/lib/dump/assets/atlas/dto';
+import type { DumpRegistryKind } from '@terrafirmagreg-team/dump/lib/dump/data/registry/dto';
+import type { TaggedReference } from '@terrafirmagreg-team/dump/lib/dump/contract/ref';
+import type { SpriteEntry } from '@terrafirmagreg-team/dump/lib/dump/gen';
+
+const TINTS = new Set(['none', 'grass', 'foliage', 'water', 'custom']);
+
+function asTint(raw: unknown): AtlasTint | undefined {
+  return typeof raw === 'string' && TINTS.has(raw) ? (raw as AtlasTint) : undefined;
+}
+
+function asTintColor(raw: unknown): string | undefined {
+  if (typeof raw === 'number' && Number.isFinite(raw)) {
+    return `#${(raw & 0xffffff).toString(16).padStart(6, '0')}`;
+  }
+  if (typeof raw !== 'string' || !raw) return undefined;
+  if (/^#[0-9a-f]{6}$/i.test(raw)) return raw;
+  if (/^#[0-9a-f]{8}$/i.test(raw)) return `#${raw.slice(-6)}`;
+  if (/^0x[0-9a-f]{6,8}$/i.test(raw)) return `#${raw.slice(-6)}`;
+  return undefined;
+}
+
+const STACK_KIND: Record<DumpRegistryKind, TaggedReference['kind']> = {
+  items: 'item',
+  blocks: 'block',
+  fluids: 'fluid',
+  entities: 'entity',
+};
+
+function pushSprite(
+  atlas: IconAtlas,
+  bySrc: Map<string, number>,
+  ref: TaggedReference,
+  sprite: SpriteEntry,
+  langKey?: string,
+): void {
+  let page = bySrc.get(sprite.image);
+  if (page === undefined) {
+    atlas.pages.push({ image: sprite.image, w: sprite.pw, h: sprite.ph });
+    page = atlas.pages.length - 1;
+    bySrc.set(sprite.image, page);
+  }
+  const tint = asTint(sprite.tint);
+  const tintColor = asTintColor(sprite.tintColor);
+  atlas.sprites.push({
+    ref,
+    page,
+    x: sprite.x,
+    y: sprite.y,
+    w: sprite.w,
+    h: sprite.h,
+    ...(tint ? { tint } : {}),
+    ...(tintColor ? { tintColor } : {}),
+    ...(langKey ? { langKey } : {}),
+  });
+}
+
+export function iconAtlasFromEntries(
+  value: unknown,
+  dataset: DatasetRef,
+  modId: string,
+  kind: DumpRegistryKind,
+  atlasKind: AtlasKind,
+): IconAtlas | null {
+  const entries = asRecord(value);
+  if (!entries) return null;
+  const stackKind = STACK_KIND[kind];
+  const atlas: IconAtlas = { sprites: [], pages: [], modId, dataset, kind: atlasKind };
+  const bySrc = new Map<string, number>();
+  for (const [key, raw] of Object.entries(entries)) {
+    const row = asRecord(raw);
+    if (!row) continue;
+    const id = asString(row.id) ?? key;
+    const langKey = asDisplay(row.display)?.name;
+    const sprite = asSpriteEntry(row.sprite);
+    if (sprite) pushSprite(atlas, bySrc, { id, kind: stackKind }, sprite, langKey);
+    const variants = row.variants;
+    if (!Array.isArray(variants)) continue;
+    for (const raw2 of variants) {
+      const variant = asRecord(raw2);
+      const variantSprite = asSpriteEntry(variant?.sprite);
+      if (!variantSprite) continue;
+      const tag = asNbt(variant?.tag);
+      pushSprite(
+        atlas,
+        bySrc,
+        { id, kind: stackKind, ...(tag !== undefined ? { tag } : {}) },
+        variantSprite,
+        asDisplay(variant?.display)?.name ?? langKey,
+      );
+    }
+  }
+  return atlas.sprites.length || atlas.pages.length ? atlas : null;
+}
+
+export function mergeAtlases(
+  parts: Array<IconAtlas | null>,
+  dataset: DatasetRef,
+  modId: string,
+  kind: AtlasKind,
+): IconAtlas | null {
+  const sources = parts.flatMap((part) => (part ? [part] : []));
+  if (!sources.length) return null;
+  const atlas: IconAtlas = { sprites: [], pages: [], modId, dataset, kind };
+  const bySrc = new Map<string, number>();
+  for (const source of sources) {
+    const pageMap = new Map<number, number>();
+    for (const [index, page] of source.pages.entries()) {
+      let mapped = bySrc.get(page.image);
+      if (mapped === undefined) {
+        atlas.pages.push({ image: page.image, w: page.w, h: page.h });
+        mapped = atlas.pages.length - 1;
+        bySrc.set(page.image, mapped);
+      }
+      pageMap.set(index, mapped);
+    }
+    for (const sprite of source.sprites) {
+      atlas.sprites.push({ ...sprite, page: pageMap.get(sprite.page) ?? 0 });
+    }
+  }
+  return atlas.sprites.length || atlas.pages.length ? atlas : null;
+}
+

package/src/lib/dump/assets/lang/load.ts

@@ -0,0 +1,19 @@
+import 'server-only';
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+import { clientDumpLang } from '@terrafirmagreg-team/dump/lib/dump/client/dump';
+import type { Lang } from '@terrafirmagreg-team/translate/types/locale';
+
+export {
+  creativeTabName,
+  isTechnicalId,
+  langString,
+  resolveName,
+} from '@terrafirmagreg-team/dump/lib/dump/assets/lang/names';
+
+export function loadMergedLangMap(
+  dataset: DatasetRef,
+  lang: Lang,
+): Promise<Record<string, string>> {
+  return clientDumpLang(dataset, lang);
+}
+

package/src/lib/dump/assets/lang/names.ts

@@ -0,0 +1,244 @@
+import {
+  nbtAt,
+  parseStackId,
+  stackIdBase,
+  type DumpNbt,
+} from '@terrafirmagreg-team/dump/lib/dump/contract/ref';
+
+function unwrapLangKey(raw: string): string {
+  const value = raw.trim();
+  return value.startsWith('{') && value.endsWith('}') && value.length > 2
+    ? value.slice(1, -1).trim()
+    : value;
+}
+
+export function langString(
+  map: Record<string, string>,
+  key: string | undefined,
+): string | undefined {
+  if (!key) return undefined;
+  const bare = unwrapLangKey(key);
+  return map[key] ?? map[bare];
+}
+
+function applyFormat(template: string, args: string[]): string {
+  let sequential = 0;
+  return template.replace(
+    /%(?:(\d+)\$)?([A-Za-z%])/g,
+    (_, n: string | undefined, conv: string) => {
+      if (conv === '%') return '%';
+      if (conv === 'n') return '\n';
+      const index = n ? Number(n) - 1 : sequential++;
+      return args[index] ?? '';
+    },
+  );
+}
+
+export function customStackName(
+  map: Record<string, string>,
+  compactId: string,
+): string | undefined {
+  const raw = nbtAt(parseStackId(compactId).nbt, 'display', 'Name');
+  if (typeof raw !== 'string' || !raw) return undefined;
+  try {
+    const node: unknown = JSON.parse(raw);
+    if (node && typeof node === 'object') {
+      return dumpTextString(map, node as Parameters<typeof dumpTextString>[1]);
+    }
+    if (typeof node === 'string') return node;
+  } catch {
+
+  }
+  return raw;
+}
+
+export function dumpTextString(
+  map: Record<string, string>,
+  text: {
+    translate?: string;
+    text?: string;
+    keybind?: string;
+    with?: unknown[];
+    extra?: unknown[];
+  },
+  keybinds?: Record<string, string>,
+): string {
+  const parts: string[] = [];
+  if (text.translate) {
+    const template = langString(map, text.translate) ?? text.translate;
+    const args = Array.isArray(text.with)
+      ? text.with.map((item) =>
+          item && typeof item === 'object'
+            ? dumpTextString(map, item as typeof text, keybinds)
+            : String(item ?? ''),
+        )
+      : [];
+    parts.push(args.length ? applyFormat(template, args) : template);
+  } else if (text.text !== undefined) {
+    parts.push(text.text);
+  } else if (text.keybind) {
+    parts.push(
+      keybinds?.[text.keybind] ?? langString(map, text.keybind) ?? text.keybind,
+    );
+  }
+  if (Array.isArray(text.extra)) {
+    for (const item of text.extra) {
+      if (item && typeof item === 'object') {
+        parts.push(dumpTextString(map, item as typeof text, keybinds));
+      }
+    }
+  }
+  return parts.join('');
+}
+
+export function dumpTextLines(
+  map: Record<string, string>,
+  lines: Array<{
+    translate?: string;
+    text?: string;
+    keybind?: string;
+    with?: unknown[];
+    extra?: unknown[];
+  }>,
+  keybinds?: Record<string, string>,
+): string[] {
+
+  return lines.map((line) => dumpTextString(map, line, keybinds));
+}
+
+export function resolveName(
+  map: Record<string, string>,
+  id: string,
+  langKey?: string,
+): string {
+  if (langKey) {
+    return langString(map, langKey) ?? langKey;
+  }
+  return langString(map, id) ?? id;
+}
+
+export function stripMcFormat(value: string): string {
+  return value.replace(/§x(?:§[0-9a-f]){6}|§[0-9a-fk-or]/gi, '');
+}
+
+const KIND_LANG_PREFIXES: Record<string, readonly string[]> = {
+  item: ['item', 'block'],
+  block: ['block', 'item'],
+  fluid: ['fluid', 'fluid_type', 'block'],
+  entity: ['entity'],
+  itemTag: ['tag.item'],
+  blockTag: ['tag.block', 'tag.item'],
+  fluidTag: ['tag.fluid'],
+  entityTag: ['tag.entity'],
+};
+
+const DEFAULT_LANG_PREFIXES = ['item', 'block', 'fluid', 'fluid_type', 'entity'];
+const TAG_LANG_PREFIXES = ['tag.item', 'tag.block', 'tag.fluid', 'tag.entity'];
+
+function stackLangKeys(
+  kind: string | undefined,
+  id: string,
+  typeKeys = true,
+): string[] {
+  const raw = parseStackId(id).id;
+  const hashed = raw.startsWith('#');
+  const resource = hashed ? raw.slice(1) : raw;
+  if (!resource.includes(':')) return [];
+  const [ns, path] = resource.split(':', 2);
+  const flat = path.replaceAll('/', '.');
+  const prefixes = hashed
+    ? ((kind ? KIND_LANG_PREFIXES[kind] : undefined) ?? TAG_LANG_PREFIXES)
+    : (KIND_LANG_PREFIXES[kind ?? ''] ?? DEFAULT_LANG_PREFIXES);
+  return [
+    ...prefixes.map((prefix) => `${prefix}.${ns}.${flat}`),
+    ...(typeKeys ? [`${ns}.type.${flat}.name`, `${ns}.type.${flat}`] : []),
+  ];
+}
+
+function nbtLangKeys(nbt: DumpNbt | undefined): string[] {
+  if (!nbt || typeof nbt !== 'object' || Array.isArray(nbt)) return [];
+  const keys: string[] = [];
+  for (const [field, value] of Object.entries(nbt)) {
+    if (!field.endsWith('Id') || field.length <= 2) continue;
+    if (typeof value !== 'string' || !value.includes(':')) continue;
+    const [ns, path] = value.split(':', 2);
+    const flat = path.replaceAll('/', '.');
+    const stem = field
+      .slice(0, -2)
+      .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+      .toLowerCase();
+    if (!stem) continue;
+    keys.push(`${ns}.${stem}.${flat}`, `${ns}.${stem}.${flat}.name`);
+  }
+  return keys;
+}
+
+export function stackDisplay(
+  langMap: Record<string, string> | undefined,
+  compactId: string,
+  kind?: string,
+  langKey?: string,
+): { name: string; localized: boolean } {
+  const parsed = parseStackId(compactId);
+  if (!langMap) return { name: langKey ?? parsed.id, localized: false };
+  const custom = customStackName(langMap, compactId);
+  if (custom) return { name: stripMcFormat(custom), localized: true };
+  const canonical = stackLangKeys(kind, parsed.id, false);
+  const candidates: { key: string | undefined; localized: boolean }[] = [
+    { key: compactId, localized: true },
+    { key: langKey, localized: true },
+    ...nbtLangKeys(parsed.nbt).map((key) => ({ key, localized: true })),
+    ...canonical.map((key) => ({ key, localized: true })),
+    ...stackLangKeys(kind, parsed.id, true)
+      .slice(canonical.length)
+      .map((key) => ({ key, localized: false })),
+    { key: parsed.id, localized: false },
+  ];
+  for (const { key, localized } of candidates) {
+    if (!key) continue;
+    const value = langString(langMap, key);
+    if (value !== undefined) {
+      return { name: stripMcFormat(value), localized };
+    }
+  }
+  return {
+    name: humanizeKey(langKey ?? stackIdBase(compactId)),
+    localized: false,
+  };
+}
+
+export function stackDisplayName(
+  langMap: Record<string, string> | undefined,
+  compactId: string,
+  kind?: string,
+  langKey?: string,
+): string {
+  return stackDisplay(langMap, compactId, kind, langKey).name;
+}
+
+export function humanizeKey(key: string): string {
+  const value = unwrapLangKey(key);
+  const segment = value.includes(':')
+    ? (value.split(':', 2)[1] ?? value)
+    : (value.split('.').pop() ?? value);
+  const words = segment
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .split(/[_.\-/]+/)
+    .filter(Boolean);
+  if (!words.length) return key;
+  return words
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+}
+
+export function creativeTabName(
+  map: Record<string, string>,
+  nameKey?: string,
+): string {
+  return langString(map, nameKey) ?? humanizeKey(nameKey ?? '');
+}
+
+export function isTechnicalId(map: Record<string, string>, id: string): boolean {
+  return resolveName(map, id) === id;
+}
+