@things-factory/headless-twin 10.1.278 → 10.1.280

package/server/service/twin-subject/twin-subject-writer.ts

@@ -1,189 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-
-import { twinError, twinWarn } from '../../engine/log.js'
-import { absoluteTime, hydratedDate } from '../../engine/read-time.js'
-import { TwinSubjectEvent } from './twin-subject-event.js'
-import { subjectsOf, type ItemResolver } from './event-subjects.js'
-
-/*
- * **대상별 사건 목록에 적는 쪽** — 저널을 쓸 때 함께 적는다.
- *
- * ── 왜 저널 쓰기와 같은 자리인가 ────────────────────────────────────────────
- * 저널을 쓰는 문은 하나다(`flushJournal` → `persistBatch`·`persistCarried`). 그 자리에서 함께 적으면
- * 두 표가 어긋나지 않는다. 다른 자리에서 나중에 적으면 「저널에는 있고 이 표에는 없는 사건」이 생기고,
- * 그것은 화면에서 오류 없이 빠진 사건이 된다.
- *
- * ── 저널이 먼저다 ──────────────────────────────────────────────────────────
- * 이 표에 적다가 실패해도 저널 쓰기를 되돌리지 않는다. 사실의 원본은 저널이고, 이 표는 다시 만들 수
- * 있다. 반대로 두면 조회를 빠르게 하려고 만든 표가 사실을 잃는 원인이 된다.
- *
- * **그러나 알리지 않고 넘기지 않는다.** 실패를 세어 창마다 한 줄 남긴다 — 알리지 않고 비면 화면이 「그 대상에는
- * 사건이 없다」고 말하게 된다.
- *
- * ── 앞으로만 채운다 ────────────────────────────────────────────────────────
- * 이미 저장된 사건을 소급해서 채우지 않는다. 이 표가 만들어진 뒤 들어오는 사건만 적힌다. 그래서 새
- * 조회 축이 필요할 때 3,128만 줄을 다시 만들지 않는다. 준비되지 않은 구간은 조회하는 쪽이 말한다
- * (§`twin-subject-query` 의 `coveredFrom`).
- *
- * 설계: `operato-twin/design/plans/read-models.md`
- */
-
-/** 한 번에 넣는 줄 수 — 저널 쓰기와 같은 규율(드라이버 파라미터 상한). */
-const CHUNK = 500
-
-/** 적다가 실패한 것을 센다 — 트윈마다. 알리지 않고 비는 것을 막는 유일한 신호다. */
-const failures = new Map<string, { count: number; lastLogMs: number; lastError: string }>()
-
-/** 같은 실패를 매번 적지 않는다 — 로그가 그 자체로 부하가 된다. */
-const FAIL_LOG_MS = 60_000
-
-export interface SubjectWriteEntry {
-  envelope: any
-  revision: number
-  /** 저널 줄의 id — 알면 함께 둔다. 벌크 저장에서는 모를 수 있다(그때는 비운다). */
-  eventId?: string
-}
-
-/**
- * 이 배치의 사건들이 가리키는 대상을 적는다 — 적은 줄 수를 돌려준다.
- *
- * `itemOf` 는 개체 식별자에서 선언된 품목을 찾아 주는 함수다. 없으면 품목 줄을 만들지 않는다 —
- * 짐작으로 이으면 남의 품목 이력에 이 사건이 섞인다(§`event-subjects`).
- */
-export async function writeSubjectRows(
-  domainId: string,
-  instanceId: string,
-  entries: readonly SubjectWriteEntry[],
-  itemOf?: ItemResolver
-): Promise<number> {
-  if (!entries.length) return 0
-
-  const rows: any[] = []
-  for (const { envelope, revision, eventId } of entries) {
-    const eventTime = timeOf(envelope)
-    /*
-     * 시각을 모르는 사건은 이 표에 넣지 않는다. 이 표의 유일한 쓸모가 「시각순 목록」이고, 시각이 없는
-     * 줄은 그 목록의 어디에도 놓을 수 없다. 넣고 「지금」으로 메우면 그 사건이 최근으로 보인다.
-     */
-    if (!eventTime) continue
-    const eventType = String(envelope?.eventType ?? '').trim()
-    if (!eventType) continue
-
-    for (const s of subjectsOf(envelope, { itemOf })) {
-      rows.push({
-        domain: { id: domainId },
-        instanceId,
-        subjectKind: s.kind,
-        subjectId: s.id,
-        eventTime,
-        revision,
-        eventType,
-        ...(eventId ? { eventId } : {})
-      })
-    }
-  }
-  if (!rows.length) return 0
-
-  try {
-    const repo = getRepository(TwinSubjectEvent)
-    for (let i = 0; i < rows.length; i += CHUNK) await repo.insert(rows.slice(i, i + CHUNK))
-    return rows.length
-  } catch (err: any) {
-    noteFailure(domainId, instanceId, rows.length, err?.message ?? String(err))
-    return 0
-  }
-}
-
-/** 사건의 시각 — 봉투가 말하는 값만 쓴다. 없으면 `null`(지금으로 메우지 않는다). */
-function timeOf(envelope: any): Date | null {
-  /* 봉투는 컬럼이 아니다 — 정규 계약이 절대시각을 요구하므로 그 규칙으로 읽는다(§`absoluteTime`). */
-  return absoluteTime(envelope?.eventTime ?? envelope?.data?.at)
-}
-
-function noteFailure(domainId: string, instanceId: string, rows: number, message: string): void {
-  const key = `${domainId}:${instanceId}`
-  const f = failures.get(key) ?? { count: 0, lastLogMs: 0, lastError: '' }
-  f.count += rows
-  f.lastError = message
-  const now = Date.now()
-  if (now - f.lastLogMs >= FAIL_LOG_MS) {
-    f.lastLogMs = now
-    twinWarn(
-      `[twin-subject] "${instanceId}" 대상 목록에 적지 못했다 — 지금까지 ${f.count}줄. ` +
-        `저널에는 그 사건이 있으므로 사실은 잃지 않았지만, 이 트윈의 이력 화면에 그만큼이 비어 있다: ${message}`
-    )
-  }
-  failures.set(key, f)
-}
-
-/** 적지 못한 줄 수 — 조회하는 쪽이 「이 표가 온전한가」를 말할 수 있게. */
-export function subjectWriteFailures(domainId: string, instanceId: string): number {
-  return failures.get(`${domainId}:${instanceId}`)?.count ?? 0
-}
-
-/** 시험이 쓰는 초기화 — 프로세스 안의 셈이므로 시험마다 비운다. */
-export function resetSubjectWriteFailures(): void {
-  failures.clear()
-}
-
-/**
- * 보관 상한 — 이 트윈에서 이 시각보다 오래된 줄을 지운다.
- *
- * 이 표는 **버릴 수 있는 값**이다. 지우면 그 구간의 이력 조회가 느려지고(저널로 답한다) 사실은 사라지지
- * 않는다. 그래서 저널보다 짧게 둘 수 있고, 그러는 편이 낫다 — 화면은 최근을 본다.
- *
- * 저널 정리와 같은 창에서 돌린다(§`TwinEngine.pruneJournal`). 나눠서 지우는 규율도 같다.
- */
-export async function pruneSubjectRows(
-  domainId: string,
-  instanceId: string,
-  cutoff: Date,
-  budgetMs: number,
-  batch: number
-): Promise<number> {
-  let deleted = 0
-  const startedMs = Date.now()
-  for (;;) {
-    /*
-     * 경계를 시각으로 찾는다 — 목차가 `(domain, instance, eventTime)` 이므로 그 순서로 물어야 쓴다.
-     * 저널 정리에서 같은 것을 실측으로 배웠다(리비전 순으로 물으면 목차를 못 쓴다).
-     */
-    const edge = await getRepository(TwinSubjectEvent)
-      .createQueryBuilder('s')
-      .select('s.eventTime', 'eventTime')
-      .where('s.domain = :domainId', { domainId })
-      .andWhere('s.instanceId = :instanceId', { instanceId })
-      .andWhere('s.eventTime < :cutoff', { cutoff })
-      .orderBy('s.eventTime', 'ASC')
-      .offset(batch - 1)
-      .limit(1)
-      .getRawOne<{ eventTime: unknown }>()
-      .catch(() => null)
-
-    /* 원시 결과의 컬럼 값은 드라이버에게 해석시킨다(§`hydratedDate`). */
-    const upTo = hydratedDate(getRepository(TwinSubjectEvent), 'eventTime', edge?.eventTime)
-
-    const del = getRepository(TwinSubjectEvent)
-      .createQueryBuilder()
-      .delete()
-      .from(TwinSubjectEvent)
-      .where('domain_id = :domainId', { domainId })
-      .andWhere('instance_id = :instanceId', { instanceId })
-    const res = await (upTo
-      ? del.andWhere('event_time <= :upTo', { upTo })
-      : del.andWhere('event_time < :cutoff', { cutoff })
-    )
-      .execute()
-      .catch(err => {
-        twinError('[twin-subject] prune fail', err?.message ?? err)
-        return { affected: 0 }
-      })
-
-    const n = res.affected ?? 0
-    deleted += n
-    if (!n) break
-    if (Date.now() - startedMs >= budgetMs) break
-    await new Promise(resolve => setImmediate(resolve))
-  }
-  return deleted
-}

package/server/service/twin-target/index.ts

@@ -1,5 +0,0 @@
-import { TwinTarget } from './twin-target.js'
-import { TwinTargetResolver } from './twin-target-resolver.js'
-
-export const entities = [TwinTarget]
-export const resolvers = [TwinTargetResolver]

package/server/service/twin-target/twin-target-resolver.ts

@@ -1,142 +0,0 @@
-import { Arg, Ctx, Directive, Float, Mutation, Query, Resolver } from 'type-graphql'
-
-import { getRepository } from '@things-factory/shell'
-
-import { TwinTarget } from './twin-target.js'
-import { TWIN_METRIC, isTwinMetric } from '../../engine/kpi-target.js'
-
-/*
- * 운영 목표 조회·편집 — **현장 관리자가 트윈 화면에서** 고친다(사용자 결정 2026-08-02).
- *
- * 경영 KPI 관리메뉴가 아니라 여기인 이유: 목표가 숫자 옆에 있어야 맥락이 살고, 운영 임계는 자주
- * 조정된다. 조직 단위 기간 평가는 `@things-factory/kpi` 의 일이고 이쪽으로 베껴 오지 않는다.
- */
-/*
- * **쓰기는 막고 읽기는 연다** (2026-08-06 · ADR-0027).
- *
- * 이 리졸버는 트윈 리졸버 중 **유일하게** 권한 게이트를 갖는데, 처음에는 우회 표시가 없었다
- * (`@privilege(category:"twin", privilege:"query")`). 그러면 `twin/query`·`twin/mutation` 권한을
- * 실제로 부여받은 사용자만 쓸 수 있는데 — **저장소 어디에도 그 권한을 만드는 곳이 없다.** 결과는
- * 도메인 소유자도 슈퍼유저도 목표를 걸 수 없는 상태였다: 성과 화면의 목표 버튼이 "Unauthorized" 로
- * 떨어지고, 이 관점의 최상위 기능(§5 목표 프레임)이 **아무도 쓸 수 없는 채로** 놓여 있었다.
- *
- * 그래서 프레임워크의 통용 관용구를 따른다 — 가장 가까운 형제인 `@things-factory/kpi`(목표·지표 관리)가
- * 74곳 전부 `domainOwnerGranted: true, superUserGranted: true` 를 쓴다. 같은 성격의 조작(무엇을 잘한
- * 것으로 볼지 정하는 일)이므로 같은 자세를 쓴다: **현장을 소유한 사람은 바로 쓰고**, 다른 사람에게
- * 맡기려면 `twin` 권한을 부여한다.
- *
- * 이제 트윈의 **모든 변경**에 같은 게이트가 있다(ADR-0027) — 처음에는 이 리졸버 하나만 게이트를 갖는
- * 반쪽이었다. 조회 게이트는 걷었다: 같은 판정이 `twinKpi` 로 이미 열려 있어 지키는 것이 없었다.
- */
-@Resolver()
-export class TwinTargetResolver {
-  /* 조회에는 게이트를 두지 않는다 — 같은 판정이 `twinKpi.targets` 로 이미 열려 있어(그쪽은 게이트가
-     없다) 여기만 막으면 지키는 것 없이 화면만 깨진다. 읽기의 경계는 **테넌트 소속**이다. */
-  @Query(returns => [String], {
-    description:
-      'The metric ids a twin target may refer to. Fixed in one place so a target and the fact it judges can never drift into two names.'
-  })
-  async twinTargetMetrics(): Promise<string[]> {
-    return Object.keys(TWIN_METRIC)
-  }
-
-
-  @Query(returns => [TwinTarget], {
-    description:
-      'Operational targets in scope — site-wide targets for the space plus targets bound to the given instance. Callers judge with the narrower one when both exist.'
-  })
-  async twinTargets(
-    @Ctx() context: ResolverContext,
-    @Arg('spaceId', { nullable: true }) spaceId?: string,
-    @Arg('instanceId', { nullable: true }) instanceId?: string
-  ): Promise<TwinTarget[]> {
-    const domainId = context.state.domain.id
-    const rows = await getRepository(TwinTarget).find({ where: { domain: { id: domainId } } })
-    return rows.filter(r => (spaceId && r.spaceId === spaceId) || (instanceId && r.instanceId === instanceId))
-  }
-
-  @Directive('@privilege(category: "twin", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => Boolean, {
-    description:
-      'Create or update one operational target. The metric must be one of twinTargetMetrics — an unknown name is rejected rather than stored, because a target nobody can evaluate reads as "no target" and hides the gap.'
-  })
-  async saveTwinTarget(
-    @Arg('metric') metric: string,
-    @Arg('target', type => Float) target: number,
-    @Ctx() context: ResolverContext,
-    @Arg('spaceId', { nullable: true }) spaceId?: string,
-    @Arg('instanceId', { nullable: true }) instanceId?: string,
-    @Arg('axis', { nullable: true }) axis?: string,
-    @Arg('axisKey', { nullable: true }) axisKey?: string
-  ): Promise<boolean> {
-    if (!isTwinMetric(metric)) throw new Error(`unknown twin metric "${metric}" — see twinTargetMetrics`)
-    if (!Number.isFinite(target)) throw new Error('target must be a finite number')
-    if (!spaceId && !instanceId) throw new Error('a target must be scoped to a space or an instance')
-    /* 축만 있고 값이 없으면 **어디에 거는 목표인지 알 수 없다** — 알리지 않고 전체 목표로 만들지 않는다
-       (그러면 사용자는 구역 목표를 걸었다고 믿는데 전체가 바뀐다). */
-    if (axis && !axisKey) throw new Error('axisKey is required when axis is given')
-    if (!axis && axisKey) throw new Error('axis is required when axisKey is given')
-    const domainId = context.state.domain.id
-    const repo = getRepository(TwinTarget)
-    const existing = await repo.findOne({
-      where: { domain: { id: domainId }, spaceId: spaceId ?? null, instanceId: instanceId ?? null, metric, axis: axis ?? null, axisKey: axisKey ?? null } as any
-    })
-    await repo.save(
-      repo.create({
-        ...(existing ?? {}),
-        domain: { id: domainId } as any,
-        spaceId: spaceId ?? null as any,
-        instanceId: instanceId ?? null as any,
-        axis: axis ?? null as any,
-        axisKey: axisKey ?? null as any,
-        metric,
-        target,
-        ...(existing ? { updater: context.state.user } : { creator: context.state.user, updater: context.state.user })
-      })
-    )
-    return true
-  }
-
-  @Directive('@privilege(category: "twin", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => Boolean, { description: 'Remove an operational target. Removing a target removes the judgement, not the fact — the metric keeps being reported without a verdict.' })
-  async deleteTwinTarget(
-    @Arg('metric') metric: string,
-    @Ctx() context: ResolverContext,
-    @Arg('spaceId', { nullable: true }) spaceId?: string,
-    @Arg('instanceId', { nullable: true }) instanceId?: string,
-    @Arg('axis', { nullable: true }) axis?: string,
-    @Arg('axisKey', { nullable: true }) axisKey?: string
-  ): Promise<boolean> {
-    const domainId = context.state.domain.id
-    const repo = getRepository(TwinTarget)
-
-    /*
-     * **찾아서 그 행만 지운다.** 예전에는 조건 객체를 `delete()` 에 그대로 넘겼는데 **아무 행도
-     * 안 지워지면서 `true` 를 돌려줬다.** 사용자는 목표를 지웠다고 믿고 화면을 떠나는데 판정은 그대로
-     * 남는다(실화면에서 그렇게 당했다).
-     *
-     * 무엇이 조건을 깨뜨렸는지는 단정하지 않는다 — 이 조건에는 `domain` 관계 객체와 `null` 값들이
-     * 함께 들어 있었고(`instanceId`·`axis`·`axisKey`), 둘 다 `delete()` 의 조건 해석에서 흔한 함정이다.
-     * 같은 관계-객체 패턴을 쓰는 `resetJournal` 은 실제로 잘 지우므로 관계 객체 하나만으로 설명되지
-     * 않는다. `null` 조건이 `IS NULL` 이 아니라 `= NULL` 로 나갔을 가능성이 크다.
-     *
-     * 그래서 조건을 고쳐 맞추는 대신 **행을 찾아 id 로 지운다**: 저장 경로와 **같은 조회 규칙**을
-     * 쓰므로 규칙이 갈라지지 않고(`findOne` 은 `null` 을 제대로 다룬다), 지우는 대상이 정확히 한
-     * 행이라 넓게 지울 위험도 없다.
-     */
-    const row = await repo.findOne({
-      where: {
-        domain: { id: domainId },
-        spaceId: spaceId ?? null,
-        instanceId: instanceId ?? null,
-        axis: axis ?? null,
-        axisKey: axisKey ?? null,
-        metric
-      } as any
-    })
-    /* 지울 것이 없으면 **없었다고 답한다.** 지우지 않고 true 를 주면 위와 같은 거짓말이 된다. */
-    if (!row) return false
-    await repo.delete(row.id)
-    return true
-  }
-}

package/server/service/twin-target/twin-target.ts

@@ -1,97 +0,0 @@
-import { CreateDateColumn, Entity, Index, Column, RelationId, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
-import { ObjectType, Field, ID, Float } from 'type-graphql'
-
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-/*
- * TwinTarget — **운영 목표.** "이 구간의 처리량이 목표에 닿았나" 를 판단하는 기준선.
- *
- * ── 왜 트윈이 갖나 (사용자 결정 2026-08-02) ─────────────────────────────────
- * `@things-factory/kpi` 와 **경계를 나눈다**:
- *   트윈(여기)      이 구간·이 교대·이 공간의 **즉시 판단**. 현장 관리자가 트윈 화면에서 고친다.
- *                   값은 저널 폴드에서 그때그때 계산된다(저장된 값을 읽지 않는다).
- *   packages/kpi    **기간 평가**(조직·분기·점수·가중치·알림). 값이 저장돼 있어야 도는 체계다.
- *
- * 지키는 규칙 하나: **트윈은 경영 목표를 복제하지 않는다.** 조직 단위 평가가 필요하면 트윈의 사실을
- * 내보내 그쪽이 소비하고, 그쪽 목표를 여기로 베껴 오지 않는다 — 베끼는 순간 두 개의 진실이 된다.
- *
- * ── 범위 (scope) ───────────────────────────────────────────────────────────
- * `spaceId` 로 현장 전체에, `instanceId` 로 트윈 하나에 건다. 둘 다 있으면 **인스턴스가 이긴다**
- * (좁은 선언이 넓은 선언을 덮는다 — 예외를 표현할 수 있어야 한다).
- *
- * 관점 축별 목표(구역마다 다른 목표)는 **아직 아니다** — 축 교차는 목표가 화면에서 쓰이기 시작한 뒤의
- * 일이고, 처음부터 넣으면 쓰이지 않는 구조가 먼저 굳는다(performance.md §5.4-5).
- *
- * (CLAUDE.md: 모든 @ObjectType/@Field 영문 description 필수.)
- */
-@Entity()
-@Index('ix_twin_target_0', (e: TwinTarget) => [e.domain, e.spaceId, e.instanceId, e.metric, e.axis, e.axisKey], { unique: true })
-@ObjectType({
-  description:
-    'An operational performance target for a twin metric — the line that turns a measured number into a judgement. Scoped to a space or to a single instance (instance wins over space, so an exception can be expressed). Distinct from @things-factory/kpi targets, which evaluate organizations over periods; twin targets are for immediate, on-site judgement and are never copied from the management KPI system.'
-})
-export class TwinTarget {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID, { description: 'Unique identifier of the target record.' })
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain, { nullable: true, description: 'Owning tenant domain.' })
-  domain?: Domain
-
-  @RelationId((e: TwinTarget) => e.domain)
-  domainId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Space this target applies to (site-wide). Empty when the target is bound to a single instance.' })
-  spaceId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Instance this target applies to. When both space and instance match, the instance target wins so an exception can be expressed.' })
-  instanceId?: string
-
-  /**
-   * 관점 축과 그 값 — **"이 구역만", "이 교대만" 목표가 다르다.**
-   *
-   * 둘 다 비어 있으면 **전체 목표**다(창 전체의 집계를 판정한다). 축 목표는 전체 목표를 덮지 않는다 —
-   * 다른 질문이기 때문이다: "현장 전체가 100건" 과 "용접 구역이 30건" 은 동시에 참일 수 있다.
-   */
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Perspective axis this target applies to (area, shift, resource, taskKind, location, order). Empty means the target judges the window total. An axis target does not override the total — "the site does 100" and "the weld area does 30" are both true at once.' })
-  axis?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'The value on that axis (an area id, a shift name…). Required when axis is set.' })
-  axisKey?: string
-
-  @Column()
-  @Field({ description: 'Metric id from the twin metric vocabulary (throughput.tasks, workTime.p50Ms, …). Names are fixed in one place so target and fact never drift into two dialects.' })
-  metric: string
-
-  @Column({ type: 'float' })
-  @Field(type => Float, { description: 'The target value, in the metric\'s own unit (count, milliseconds, ratio). Whether higher or lower is better is a property of the metric, not of this record — so a target can never be declared in the wrong direction.' })
-  target: number
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true, description: 'User who created this target.' })
-  creator?: User
-
-  @RelationId((e: TwinTarget) => e.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true, description: 'User who last updated this target.' })
-  updater?: User
-
-  @RelationId((e: TwinTarget) => e.updater)
-  updaterId?: string
-
-  @CreateDateColumn()
-  @Field({ nullable: true, description: 'Timestamp when the target was created.' })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true, description: 'Timestamp when the target was last updated.' })
-  updatedAt?: Date
-}

package/server/types/global.d.ts

@@ -1,22 +0,0 @@
-/**
- * Global type definitions for the headless-twin module.
- */
-
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-declare global {
-  /**
-   * GraphQL Resolver Context — available in every @Ctx() decorated parameter.
-   */
-  interface ResolverContext {
-    state: {
-      domain: Domain
-      user: User
-      [key: string]: any
-    }
-    [key: string]: any
-  }
-}
-
-export {}

package/shared/axis-read.ts

@@ -1,28 +0,0 @@
-/*
- * 축의 값을 **어디서 읽나** — 규칙 한 곳. (design/profiles/ems.md §10 6.5단계)
- *
- * ── 왜 함수로 빼나 ─────────────────────────────────────────────────────────
- * 개념 지도는 상태 축을 `state[축이름]` 으로 읽고 있었다. 에너지의 수요 구간은 `state.energy.closed`
- * 에 살아서 그 규칙으로는 **언제나 `undefined`** 다 — 카드가 「관측 없음」으로 굳고, 원인은 화면도
- * 서버도 말해 주지 않는다(축은 선언돼 있고 상태에도 값이 있는데 이름이 안 맞을 뿐이다).
- *
- * 커널 선언이 이미 그 자리를 말한다(`TwinAxisInfo.path`). 그래서 규칙은 한 줄이다:
- * **경로가 있으면 그 경로로, 없으면 축 이름으로.** 리졸버 안에 두면 시험이 DB 를 물어야 하므로
- * 순수 함수로 빼 둔다.
- */
-
-/** 중첩 경로를 따라간다 — 중간이 없으면 `undefined`(빈 객체로 메우지 않는다). */
-export function atPath(obj: any, path: string): any {
-  return path.split('.').reduce((o: any, k: string) => (o == null ? undefined : o[k]), obj)
-}
-
-/**
- * 그 축의 값 — 배열이면 목록, 객체면 그릇, 없으면 `undefined`.
- *
- * `undefined` 와 빈 배열은 **다르다**: 앞은 「모른다·아직 안 옴」이고 뒤는 「없다」다. 이 함수는 그
- * 구별을 지우지 않는다 — 소비처가 `emptyBecause` 를 그 차이로 만든다.
- */
-export function axisValueOf(state: any, axis: { axis: string; path?: string }): any {
-  if (!state || !axis?.axis) return undefined
-  return axis.path ? atPath(state, axis.path) : state[axis.axis]
-}