@operato/twin-kernel 0.7.10 → 0.7.12

package/dist/contract.d.ts

@@ -336,14 +336,6 @@ export interface ResourceClassDef extends EffectivePeriod {
     /** 이 등급의 적격을 정하는 시험 명세들 — 표준 `TestSpecificationID`. */
     testSpecificationIds?: TestSpecificationRefs;
 }
-/**
- * 등급 소속을 **상속을 타고 닫는다** — "이 개체가 이 등급으로 통하는가".
- *
- * 순환은 방문 집합으로 끊는다(잘못된 마스터가 무한 루프를 만들지 않게). 등급 정의가 없으면 소속
- * 그대로만 본다 — 정의를 요구하지 않는다(정의를 싣지 않은 트윈이 그대로 동작해야 한다).
- *
- * `at` 를 주면 **유효 기간 밖의 등급은 제외**한다. 안 주면 기간을 보지 않는다(모르면 판단하지 않는다).
- */
 export declare function classClosure(directIds: readonly string[] | undefined, defs: readonly ResourceClassDef[] | undefined, at?: ISOTime): Set<string>;
 /**
  * 우선순위 — **ISA-95 `Priority`**(`JobOrderType`·`OperationsRequestType`, 타입은 `PriorityType` =
@@ -1133,6 +1125,20 @@ export interface OrderState {
      * 이것도 상태에 없어서 되살아난 오더는 빈 문자열을 갖고, 이후 모든 이벤트의 거래번호가 빈다.
      */
     bizTransaction?: string;
+    /**
+     * 도메인이 **약속해 둔 자리와 시각창** — 어디로/언제 들이기로 했는가.
+     *
+     * ── 왜 사실에 실어야 하나 (2026-08-17) ─────────────────────────────────────
+     * 야드 트윈이 재기동 뒤 **첫 틱에서 죽었다.** 어포인트먼트를 받을 때 도크 도어를 정해 두는데
+     * 그것이 어느 사실에도 실리지 않아, 웜스타트가 오더는 되살리고 배정은 잃었다. 그리고 다음 틱에
+     * 「그 도어의 점유」를 읽다 예외가 났다(`Cannot read properties of undefined`). 안전망이 그 트윈만
+     * 세워 다른 트윈은 살았지만, 야드 트윈 셋이 부팅마다 죽는 상태였다.
+     *
+     * `allocated` 가 두 자리에만 있어 계보를 잃었던 것과 **같은 부류**다: 상태가 필요로 하는 것을
+     * 사실이 갖고 있지 않으면 재기동을 넘지 못한다.
+     */
+    dockDoor?: string;
+    windowStartMs?: number;
     /** 우선순위 — 표준 `OperationsRequest.Priority`. 작은 값이 급하다. 오더 할당 순서를 정한다. */
     priority?: number;
     /** 예정 착수 — 표준 `OperationsRequest.StartTime`. */
@@ -1678,6 +1684,20 @@ export interface OrderStatusDelta {
      */
     allocated?: string[];
     bizTransaction?: string;
+    /**
+     * 도메인이 **약속해 둔 자리와 시각창** — 어디로/언제 들이기로 했는가.
+     *
+     * ── 왜 사실에 실어야 하나 (2026-08-17) ─────────────────────────────────────
+     * 야드 트윈이 재기동 뒤 **첫 틱에서 죽었다.** 어포인트먼트를 받을 때 도크 도어를 정해 두는데
+     * 그것이 어느 사실에도 실리지 않아, 웜스타트가 오더는 되살리고 배정은 잃었다. 그리고 다음 틱에
+     * 「그 도어의 점유」를 읽다 예외가 났다(`Cannot read properties of undefined`). 안전망이 그 트윈만
+     * 세워 다른 트윈은 살았지만, 야드 트윈 셋이 부팅마다 죽는 상태였다.
+     *
+     * `allocated` 가 두 자리에만 있어 계보를 잃었던 것과 **같은 부류**다: 상태가 필요로 하는 것을
+     * 사실이 갖고 있지 않으면 재기동을 넘지 못한다.
+     */
+    dockDoor?: string;
+    windowStartMs?: number;
 }
 export declare const CMD: {
     readonly orderHold: "order.hold";

package/dist/contract.js

@@ -184,17 +184,42 @@ export function meetsTests(required, results, at) {
 export function effectivityAt(p, at) {
     if (!p || !at)
         return undefined;
-    const atMs = Date.parse(at);
+    const atMs = parsedMs(at);
     if (!Number.isFinite(atMs))
         return undefined;
-    const from = p.effectiveStart ? Date.parse(p.effectiveStart) : NaN;
+    const from = p.effectiveStart ? parsedMs(p.effectiveStart) : NaN;
     if (Number.isFinite(from) && atMs < from)
         return 'not-yet';
-    const to = p.effectiveEnd ? Date.parse(p.effectiveEnd) : NaN;
+    const to = p.effectiveEnd ? parsedMs(p.effectiveEnd) : NaN;
     if (Number.isFinite(to) && atMs > to)
         return 'expired';
     return undefined;
 }
+/*
+ * ── 같은 시각 문자열을 몇천 번 다시 파싱하지 않는다 (2026-08-17 프로파일) ───
+ *
+ * 커널 틱의 비용을 재 보니 `Date.parse` 를 부르는 이 판정들이 **틱 시간의 5분의 1** 이었다. 한 틱
+ * 안에서 오가는 시각 문자열은 사실 몇 개뿐이다: 그 틱의 "지금" 하나와, 마스터에 적힌 유효기간들
+ * (부팅 뒤 바뀌지 않는다). 같은 문자열이 계속 다시 파싱되고 있었다.
+ *
+ * 값이 아니라 **문자열 자체**를 열쇠로 기억한다 — 같은 문자열은 언제 물어도 같은 밀리초다(ISO 시각은
+ * 절대 시각이다). 그래서 이 기억은 결과를 바꾸지 않는다: 캐시가 없을 때와 정확히 같은 수를 낸다.
+ *
+ * 크기를 묶는다. 시각 문자열은 트윈이 굴러가는 동안 계속 새로 생기므로(틱마다 새 "지금"), 묶지 않으면
+ * 이 표가 곧 누수다. 실제로 필요한 것은 최근 몇 개뿐이다.
+ */
+const PARSED_MAX = 64;
+const parsedCache = new Map();
+function parsedMs(at) {
+    const hit = parsedCache.get(at);
+    if (hit !== undefined)
+        return hit;
+    const ms = Date.parse(at);
+    if (parsedCache.size >= PARSED_MAX)
+        parsedCache.clear();
+    parsedCache.set(at, ms);
+    return ms;
+}
 /**
  * 등급 소속을 **상속을 타고 닫는다** — "이 개체가 이 등급으로 통하는가".
  *
@@ -203,8 +228,30 @@ export function effectivityAt(p, at) {
  *
  * `at` 를 주면 **유효 기간 밖의 등급은 제외**한다. 안 주면 기간을 보지 않는다(모르면 판단하지 않는다).
  */
+/*
+ * ── 등급 정의 색인은 한 번만 만든다 (2026-08-17 프로파일) ───────────────────
+ *
+ * `classClosure` 는 부를 때마다 정의 목록으로 `Map` 을 새로 지었다. 그런데 등급 정의는 모델을 실을 때
+ * 정해지고 그 뒤 바뀌지 않는 목록이다 — 능력 판정마다 같은 표를 다시 짓느라 **틱 시간의 7분의 1** 을
+ * 썼다(프로파일 `classClosure` 14%).
+ *
+ * 배열 **자체**를 열쇠로 기억한다(`WeakMap`). 목록이 바뀌면 그것은 다른 배열이므로 새 표가 만들어지고,
+ * 목록이 사라지면 표도 함께 사라진다 — 무효화를 따로 관리할 것이 없다.
+ */
+const classIndexCache = new WeakMap();
+function classIndex(defs) {
+    if (!defs)
+        return EMPTY_CLASS_INDEX;
+    const hit = classIndexCache.get(defs);
+    if (hit)
+        return hit;
+    const built = new Map(defs.map(d => [d.id, d]));
+    classIndexCache.set(defs, built);
+    return built;
+}
+const EMPTY_CLASS_INDEX = new Map();
 export function classClosure(directIds, defs, at) {
-    const byId = new Map((defs ?? []).map(d => [d.id, d]));
+    const byId = classIndex(defs);
     const inWindow = (d) => !d || effectivityAt(d, at) === undefined;
     const out = new Set();
     const stack = [...(directIds ?? [])];
@@ -499,8 +546,17 @@ export function activeShiftAt(entries, atMs, utcOffsetMinutes) {
  * 06시 교대가 **7시간 틀렸다.** 선언이 없으면 UTC 이고, 그 기본값을 숨기지 않고 밝힌다.
  */
 export function minuteOfDayAt(ms, utcOffsetMinutes) {
-    const d = new Date(ms + (utcOffsetMinutes ?? 0) * 60_000);
-    return d.getUTCHours() * 60 + d.getUTCMinutes();
+    /*
+     * `new Date(...)` 를 만들지 않는다 (2026-08-17 프로파일).
+     *
+     * 교대 판정이 이것을 자원마다 부르는데, 그때마다 Date 객체를 하나 만들고 버렸다 — 틱 시간의 12% 였다.
+     * UTC 기준 「하루 안의 분」은 나눗셈으로 나온다(getUTCHours 도 같은 계산을 한다). 음수 시각(1970 이전)
+     * 에서도 같은 답이 되도록 나머지를 한 번 더 올린다.
+     */
+    const shifted = ms + (utcOffsetMinutes ?? 0) * 60_000;
+    const DAY = 86_400_000;
+    const inDay = ((shifted % DAY) + DAY) % DAY;
+    return Math.floor(inDay / 60_000);
 }
 export function offCalendarReasonAt(r, ms, utcOffsetMinutes) {
     if (!offCalendarAt(r, ms, utcOffsetMinutes))
@@ -539,13 +595,41 @@ export function offCalendarAt(r, ms, utcOffsetMinutes) {
 export function requiredTestsFor(directIds, defs, at) {
     if (!defs?.length)
         return [];
+    /*
+     * ── 같은 답을 틱마다 다시 닫지 않는다 (2026-08-17 프로파일) ──────────────
+     *
+     * 이 함수의 답은 **셋에만** 달려 있다: 소속 등급, 등급 정의, 판정 시각. 자원의 상태(고장·교대·시험
+     * 결과)는 여기 들어오지 않는다 — 그것은 `capabilityOf` 가 따로 본다. 그런데 능력 판정이 자원마다·
+     * 작업마다 이것을 불러, 같은 셋으로 같은 답을 한 틱에 수백 번 다시 만들었다(닫기 + 정의 순회 =
+     * 프로파일 21%).
+     *
+     * 그래서 그 셋을 열쇠로 기억한다. 정의 목록은 배열 **자체**로 구분하므로(`classIndex` 와 같은 규율)
+     * 모델이 바뀌면 다른 열쇠가 된다. 시각이 흐르면 열쇠도 바뀌므로 유효기간 판정이 낡지 않는다.
+     *
+     * 돌려주는 배열은 **읽기 전용으로 다뤄야 한다** — 기억된 배열을 부르는 쪽이 고치면 다음 호출자가
+     * 고쳐진 것을 받는다. 지금 모든 소비처는 읽기만 한다(그래서 복사하지 않는다: 복사하면 이 기억의
+     * 값이 절반은 사라진다).
+     */
+    const cache = requiredTestsCache.get(defs) ?? new Map();
+    if (!requiredTestsCache.has(defs))
+        requiredTestsCache.set(defs, cache);
+    const key = `${at ?? ''}\u0000${(directIds ?? []).join('\u0001')}`;
+    const hit = cache.get(key);
+    if (hit)
+        return hit;
     const closure = classClosure(directIds, defs, at);
     const required = [];
     for (const d of defs)
         if (closure.has(d.id))
             required.push(...(d.testSpecificationIds ?? []));
+    /* 시각이 열쇠에 들어가므로 이 표는 트윈이 굴러가는 동안 계속 자란다 — 크기를 묶는다. */
+    if (cache.size >= REQUIRED_TESTS_MAX)
+        cache.clear();
+    cache.set(key, required);
     return required;
 }
+const REQUIRED_TESTS_MAX = 512;
+const requiredTestsCache = new WeakMap();
 /**
  * 자원의 **가용 능력을 판정한다** — 하나의 규칙, 하나의 자리.
  *

package/dist/flow-engine.d.ts

@@ -475,7 +475,21 @@ export declare abstract class FlowEngine implements TwinKernel {
      * 이미 시계가 흐른 뒤에 옮기면 그전에 낸 사실들과 시간축이 어긋나므로 **기동 직후에만** 부른다.
      */
     setClockOrigin(originMs: number): void;
+    /**
+     * 이 커널의 **지금**(ISO 문자열).
+     *
+     * ── 같은 시각을 몇천 번 다시 문자열로 만들지 않는다 (2026-08-17 프로파일) ──
+     * 능력 판정이 이 값을 자원마다·작업마다 부른다. 그래서 한 틱 안에서 이 함수가 수백 번 불리는데,
+     * 그때마다 `new Date(...).toISOString()` 이 새 문자열을 지었다 — 프로파일에서 **틱 시간의 40%** 가
+     * 여기였다.
+     *
+     * 밀리초가 같으면 문자열도 같다. 그래서 밀리초를 열쇠로 기억한다 — 근사가 아니라 **정확히 같은 값**을
+     * 내므로 판정은 하나도 달라지지 않는다. 덤으로 같은 문자열 인스턴스가 돌아오므로 그것을 다시 파싱하는
+     * 쪽(`effectivityAt`)의 캐시도 한 번에 맞는다.
+     */
     protected now(): string;
+    private nowIsoMs;
+    private nowIso;
     /**
      * 자극이 선언한 **약속**을 오더 필드로 — 표준 `OperationsRequest.Priority`·`StartTime`·`EndTime`.
      *

package/dist/flow-engine.js

@@ -589,7 +589,9 @@ export class FlowEngine {
                    사라진다(같은 사실이 델타·스냅샷·이 변환 **세 길**을 지난다). */
                 ...(o.allocated?.length ? { allocated: o.allocated } : {}),
                 ...(o.gtin ? { gtin: o.gtin } : {}),
-                ...(o.bizTransaction ? { bizTransaction: o.bizTransaction } : {})
+                ...(o.bizTransaction ? { bizTransaction: o.bizTransaction } : {}),
+                ...(o.dockDoor ? { dockDoor: o.dockDoor } : {}),
+                ...(o.windowStartMs !== undefined ? { windowStartMs: o.windowStartMs } : {})
             }));
         for (const o of observedOrders) {
             const lines = (o.lines ?? []).map(l => ({ gtin: l.gtin, requested: l.requested - (l.fulfilled ?? 0) })).filter(l => l.requested > 0);
@@ -614,7 +616,11 @@ export class FlowEngine {
                 ...(o.held ? { held: true } : {}),
                 ...(o.endTime ? { endTime: o.endTime } : {}),
                 ...(o.startTime ? { startTime: o.startTime } : {}),
-                ...(o.priority !== undefined ? { priority: o.priority } : {})
+                ...(o.priority !== undefined ? { priority: o.priority } : {}),
+                /* 약속해 둔 자리·시각창을 이어받는다 — 없으면 도메인이 「정해 뒀다」고 믿는 것을 잃는다.
+                   사실이 말해 주지 않으면(옛 저널) 비는 것이 사실이다 — 지어내지 않는다. */
+                ...(o.dockDoor ? { dockDoor: o.dockDoor } : {}),
+                ...(o.windowStartMs !== undefined ? { windowStartMs: o.windowStartMs } : {})
             });
         }
         /* 작업이 딛고 설 오더를 먼저 세운다 — 순서가 뒤바뀌면 아래 확인이 언제나 "없다" 로 답한다. */
@@ -955,6 +961,9 @@ export class FlowEngine {
                 /* 진행 중 확보분과 거래번호 — **스냅샷에도** 실어야 한다. 델타에만 실으면 스냅샷으로
                    재기동하는 경로(체크포인트)에서 그대로 잃는다(같은 사실을 두 길로 나르는 값이다). */
                 ...(o.allocated?.length ? { allocated: o.allocated.slice() } : {}),
+                /* 스냅샷도 함께 나른다 — 델타·스냅샷·복원 **세 길** 중 하나만 빠져도 재기동이 잃는다. */
+                ...(o.dockDoor ? { dockDoor: o.dockDoor } : {}),
+                ...(o.windowStartMs !== undefined ? { windowStartMs: o.windowStartMs } : {}),
                 ...(o.bizTransaction ? { bizTransaction: o.bizTransaction } : {}),
                 held: o.held
             })),
@@ -1062,7 +1071,28 @@ export class FlowEngine {
             throw new Error('clock origin must be a finite epoch millisecond value');
         this.originMs = originMs;
     }
-    now() { return new Date(this.nowMs()).toISOString(); }
+    /**
+     * 이 커널의 **지금**(ISO 문자열).
+     *
+     * ── 같은 시각을 몇천 번 다시 문자열로 만들지 않는다 (2026-08-17 프로파일) ──
+     * 능력 판정이 이 값을 자원마다·작업마다 부른다. 그래서 한 틱 안에서 이 함수가 수백 번 불리는데,
+     * 그때마다 `new Date(...).toISOString()` 이 새 문자열을 지었다 — 프로파일에서 **틱 시간의 40%** 가
+     * 여기였다.
+     *
+     * 밀리초가 같으면 문자열도 같다. 그래서 밀리초를 열쇠로 기억한다 — 근사가 아니라 **정확히 같은 값**을
+     * 내므로 판정은 하나도 달라지지 않는다. 덤으로 같은 문자열 인스턴스가 돌아오므로 그것을 다시 파싱하는
+     * 쪽(`effectivityAt`)의 캐시도 한 번에 맞는다.
+     */
+    now() {
+        const ms = this.nowMs();
+        if (ms !== this.nowIsoMs) {
+            this.nowIsoMs = ms;
+            this.nowIso = new Date(ms).toISOString();
+        }
+        return this.nowIso;
+    }
+    nowIsoMs = Number.NaN;
+    nowIso = '';
     /**
      * 자극이 선언한 **약속**을 오더 필드로 — 표준 `OperationsRequest.Priority`·`StartTime`·`EndTime`.
      *
@@ -1639,7 +1669,10 @@ export class FlowEngine {
                계보가 입력 없이 나간다(무엇이 무엇으로 바뀌었나의 절반이 사라진다). */
             ...(o.gtin ? { gtin: o.gtin } : {}),
             ...(o.allocated?.length ? { allocated: o.allocated.slice() } : {}),
-            ...(o.bizTransaction ? { bizTransaction: o.bizTransaction } : {})
+            ...(o.bizTransaction ? { bizTransaction: o.bizTransaction } : {}),
+            /* 약속해 둔 자리·시각창 — 이것이 빠져서 야드 트윈이 재기동마다 첫 틱에 죽었다(§dockDoor). */
+            ...(o.dockDoor ? { dockDoor: o.dockDoor } : {}),
+            ...(o.windowStartMs !== undefined ? { windowStartMs: o.windowStartMs } : {})
         });
     }
     // ── 내부 mechanics ─────────────────────────────────────────────────────────

package/dist/observed-reducer.js

@@ -357,6 +357,10 @@ export class ObservedReducer {
                     ...(d.gtin ? { gtin: d.gtin } : {}),
                     ...(d.allocated?.length ? { allocated: d.allocated.slice() } : {}),
                     ...(d.bizTransaction ? { bizTransaction: d.bizTransaction } : {}),
+                    /* 약속해 둔 자리·시각창도 채운다 — 시뮬만 알면 미러 위 예측이 「어디로 들일지」를 모른다.
+                       (이 필드가 어느 길에서 빠지면 무슨 일이 나는지는 §dockDoor 에 적혀 있다.) */
+                    ...(d.dockDoor ? { dockDoor: d.dockDoor } : {}),
+                    ...(d.windowStartMs !== undefined ? { windowStartMs: d.windowStartMs } : {}),
                     held: d.held
                 });
                 break;

package/dist/yms-kernel.d.ts

@@ -8,6 +8,8 @@ export declare class YmsKernel extends FlowEngine {
     private cargoSeq;
     private trailerCargo;
     private apptMode;
+    /** 도어를 못 찾아 대기시킨 오더 — 같은 말을 매 틱 반복하지 않기 위한 표시(§allocate). */
+    private doorWarned;
     /** 야드 운영 정책(상하차 방식). 기본 drop(야드 버퍼). live 는 게이트/도크 직행. */
     mode: YardMode;
     constructor(tenantId: string, policy?: AllocationPolicy, mode?: YardMode);

package/dist/yms-kernel.js

@@ -39,6 +39,8 @@ export class YmsKernel extends FlowEngine {
     cargoSeq = 0;
     trailerCargo = new Map(); // 트레일러 epc → 화물 SSCC(하차 전 opaque / 상차 예약분)
     apptMode = new Map(); // orderId → 상하차 모드(생성 시 캡처)
+    /** 도어를 못 찾아 대기시킨 오더 — 같은 말을 매 틱 반복하지 않기 위한 표시(§allocate). */
+    doorWarned = new Set();
     /** 야드 운영 정책(상하차 방식). 기본 drop(야드 버퍼). live 는 게이트/도크 직행. */
     mode;
     constructor(tenantId, policy = firstFitPolicy, mode = 'drop') {
@@ -102,7 +104,25 @@ export class YmsKernel extends FlowEngine {
             return;
         if (this.clockMs < (o.windowStartMs ?? 0))
             return; // 창 도래 전
-        const door = this.locations.get(o.dockDoor);
+        /*
+         * ── 배정된 도어가 없으면 **기다린다** (2026-08-17) ────────────────────────
+         *
+         * 예전에는 `this.locations.get(o.dockDoor!)!` 였다. 그래서 배정을 모르는 오더가 들어오면 바로
+         * 아래에서 `undefined.occupancy` 를 읽고 **틱 전체가 예외로 죽었다** — 야드 트윈 셋이 재기동마다
+         * 그렇게 멈췄다(안전망이 세운 것이지 스스로 멈춘 것이 아니다).
+         *
+         * 이제 그 오더만 대기로 남기고 **왜인지 한 번 말한다.** 매 틱 말하면 로그가 그것만 남으므로 한 번만
+         * 말하고, 조용히 넘기지도 않는다 — 조용하면 「왜 이 오더는 영원히 안 움직이나」를 아무도 답할 수 없다.
+         */
+        const door = o.dockDoor ? this.locations.get(o.dockDoor) : undefined;
+        if (!door) {
+            if (!this.doorWarned.has(o.id)) {
+                this.doorWarned.add(o.id);
+                console.warn(`[yms-kernel] order "${o.id}" waits: ${o.dockDoor ? `its dock door "${o.dockDoor}" is not in this model` : 'no dock door was assigned to it'}` +
+                    ' — the appointment cannot be scheduled until the declaration says where.');
+            }
+            return;
+        }
         const inflight = [...this.tasks.values()].some(t => t.status !== 'completed' && t.toNode === door.id);
         if (door.occupancy > 0 || inflight)
             return; // 도어 사용중/예약됨 → 대기(직렬화)

package/dist-cjs/index.cjs

@@ -261,16 +261,36 @@ function meetsTests(required, results, at) {
 }
 function effectivityAt(p, at) {
   if (!p || !at) return void 0;
-  const atMs = Date.parse(at);
+  const atMs = parsedMs(at);
   if (!Number.isFinite(atMs)) return void 0;
-  const from = p.effectiveStart ? Date.parse(p.effectiveStart) : NaN;
+  const from = p.effectiveStart ? parsedMs(p.effectiveStart) : NaN;
   if (Number.isFinite(from) && atMs < from) return "not-yet";
-  const to = p.effectiveEnd ? Date.parse(p.effectiveEnd) : NaN;
+  const to = p.effectiveEnd ? parsedMs(p.effectiveEnd) : NaN;
   if (Number.isFinite(to) && atMs > to) return "expired";
   return void 0;
 }
+var PARSED_MAX = 64;
+var parsedCache = /* @__PURE__ */ new Map();
+function parsedMs(at) {
+  const hit = parsedCache.get(at);
+  if (hit !== void 0) return hit;
+  const ms2 = Date.parse(at);
+  if (parsedCache.size >= PARSED_MAX) parsedCache.clear();
+  parsedCache.set(at, ms2);
+  return ms2;
+}
+var classIndexCache = /* @__PURE__ */ new WeakMap();
+function classIndex(defs) {
+  if (!defs) return EMPTY_CLASS_INDEX;
+  const hit = classIndexCache.get(defs);
+  if (hit) return hit;
+  const built = new Map(defs.map((d) => [d.id, d]));
+  classIndexCache.set(defs, built);
+  return built;
+}
+var EMPTY_CLASS_INDEX = /* @__PURE__ */ new Map();
 function classClosure(directIds, defs, at) {
-  const byId = new Map((defs ?? []).map((d) => [d.id, d]));
+  const byId = classIndex(defs);
   const inWindow = (d) => !d || effectivityAt(d, at) === void 0;
   const out = /* @__PURE__ */ new Set();
   const stack = [...directIds ?? []];
@@ -409,8 +429,10 @@ function activeShiftAt(entries, atMs, utcOffsetMinutes) {
   return void 0;
 }
 function minuteOfDayAt(ms2, utcOffsetMinutes) {
-  const d = new Date(ms2 + (utcOffsetMinutes ?? 0) * 6e4);
-  return d.getUTCHours() * 60 + d.getUTCMinutes();
+  const shifted = ms2 + (utcOffsetMinutes ?? 0) * 6e4;
+  const DAY = 864e5;
+  const inDay = (shifted % DAY + DAY) % DAY;
+  return Math.floor(inDay / 6e4);
 }
 function offCalendarReasonAt(r, ms2, utcOffsetMinutes) {
   if (!offCalendarAt(r, ms2, utcOffsetMinutes)) return void 0;
@@ -435,11 +457,20 @@ function offCalendarAt(r, ms2, utcOffsetMinutes) {
 }
 function requiredTestsFor(directIds, defs, at) {
   if (!defs?.length) return [];
+  const cache = requiredTestsCache.get(defs) ?? /* @__PURE__ */ new Map();
+  if (!requiredTestsCache.has(defs)) requiredTestsCache.set(defs, cache);
+  const key = `${at ?? ""}\0${(directIds ?? []).join("
")}`;
+  const hit = cache.get(key);
+  if (hit) return hit;
   const closure = classClosure(directIds, defs, at);
   const required = [];
   for (const d of defs) if (closure.has(d.id)) required.push(...d.testSpecificationIds ?? []);
+  if (cache.size >= REQUIRED_TESTS_MAX) cache.clear();
+  cache.set(key, required);
   return required;
 }
+var REQUIRED_TESTS_MAX = 512;
+var requiredTestsCache = /* @__PURE__ */ new WeakMap();
 function capabilityOf(r, ctx) {
   const at = ctx?.at;
   const eff = effectivityAt(r, at);
@@ -1323,6 +1354,10 @@ var ObservedReducer = class {
           ...d.gtin ? { gtin: d.gtin } : {},
           ...d.allocated?.length ? { allocated: d.allocated.slice() } : {},
           ...d.bizTransaction ? { bizTransaction: d.bizTransaction } : {},
+          /* 약속해 둔 자리·시각창도 채운다 — 시뮬만 알면 미러 위 예측이 「어디로 들일지」를 모른다.
+             (이 필드가 어느 길에서 빠지면 무슨 일이 나는지는 §dockDoor 에 적혀 있다.) */
+          ...d.dockDoor ? { dockDoor: d.dockDoor } : {},
+          ...d.windowStartMs !== void 0 ? { windowStartMs: d.windowStartMs } : {},
           held: d.held
         });
         break;
@@ -3188,7 +3223,9 @@ var FlowEngine = class {
          사라진다(같은 사실이 델타·스냅샷·이 변환 **세 길**을 지난다). */
       ...o.allocated?.length ? { allocated: o.allocated } : {},
       ...o.gtin ? { gtin: o.gtin } : {},
-      ...o.bizTransaction ? { bizTransaction: o.bizTransaction } : {}
+      ...o.bizTransaction ? { bizTransaction: o.bizTransaction } : {},
+      ...o.dockDoor ? { dockDoor: o.dockDoor } : {},
+      ...o.windowStartMs !== void 0 ? { windowStartMs: o.windowStartMs } : {}
     }));
     for (const o of observedOrders) {
       const lines = (o.lines ?? []).map((l) => ({ gtin: l.gtin, requested: l.requested - (l.fulfilled ?? 0) })).filter((l) => l.requested > 0);
@@ -3215,7 +3252,11 @@ var FlowEngine = class {
         ...o.held ? { held: true } : {},
         ...o.endTime ? { endTime: o.endTime } : {},
         ...o.startTime ? { startTime: o.startTime } : {},
-        ...o.priority !== void 0 ? { priority: o.priority } : {}
+        ...o.priority !== void 0 ? { priority: o.priority } : {},
+        /* 약속해 둔 자리·시각창을 이어받는다 — 없으면 도메인이 「정해 뒀다」고 믿는 것을 잃는다.
+           사실이 말해 주지 않으면(옛 저널) 비는 것이 사실이다 — 지어내지 않는다. */
+        ...o.dockDoor ? { dockDoor: o.dockDoor } : {},
+        ...o.windowStartMs !== void 0 ? { windowStartMs: o.windowStartMs } : {}
       });
     }
     const seededOrderIds = new Set(this.orders.keys());
@@ -3531,6 +3572,9 @@ var FlowEngine = class {
         /* 진행 중 확보분과 거래번호 — **스냅샷에도** 실어야 한다. 델타에만 실으면 스냅샷으로
            재기동하는 경로(체크포인트)에서 그대로 잃는다(같은 사실을 두 길로 나르는 값이다). */
         ...o.allocated?.length ? { allocated: o.allocated.slice() } : {},
+        /* 스냅샷도 함께 나른다 — 델타·스냅샷·복원 **세 길** 중 하나만 빠져도 재기동이 잃는다. */
+        ...o.dockDoor ? { dockDoor: o.dockDoor } : {},
+        ...o.windowStartMs !== void 0 ? { windowStartMs: o.windowStartMs } : {},
         ...o.bizTransaction ? { bizTransaction: o.bizTransaction } : {},
         held: o.held
       })),
@@ -3621,9 +3665,28 @@ var FlowEngine = class {
     if (!Number.isFinite(originMs)) throw new Error("clock origin must be a finite epoch millisecond value");
     this.originMs = originMs;
   }
+  /**
+   * 이 커널의 **지금**(ISO 문자열).
+   *
+   * ── 같은 시각을 몇천 번 다시 문자열로 만들지 않는다 (2026-08-17 프로파일) ──
+   * 능력 판정이 이 값을 자원마다·작업마다 부른다. 그래서 한 틱 안에서 이 함수가 수백 번 불리는데,
+   * 그때마다 `new Date(...).toISOString()` 이 새 문자열을 지었다 — 프로파일에서 **틱 시간의 40%** 가
+   * 여기였다.
+   *
+   * 밀리초가 같으면 문자열도 같다. 그래서 밀리초를 열쇠로 기억한다 — 근사가 아니라 **정확히 같은 값**을
+   * 내므로 판정은 하나도 달라지지 않는다. 덤으로 같은 문자열 인스턴스가 돌아오므로 그것을 다시 파싱하는
+   * 쪽(`effectivityAt`)의 캐시도 한 번에 맞는다.
+   */
   now() {
-    return new Date(this.nowMs()).toISOString();
+    const ms2 = this.nowMs();
+    if (ms2 !== this.nowIsoMs) {
+      this.nowIsoMs = ms2;
+      this.nowIso = new Date(ms2).toISOString();
+    }
+    return this.nowIso;
   }
+  nowIsoMs = Number.NaN;
+  nowIso = "";
   /**
    * 자극이 선언한 **약속**을 오더 필드로 — 표준 `OperationsRequest.Priority`·`StartTime`·`EndTime`.
    *
@@ -4158,7 +4221,10 @@ var FlowEngine = class {
          계보가 입력 없이 나간다(무엇이 무엇으로 바뀌었나의 절반이 사라진다). */
       ...o.gtin ? { gtin: o.gtin } : {},
       ...o.allocated?.length ? { allocated: o.allocated.slice() } : {},
-      ...o.bizTransaction ? { bizTransaction: o.bizTransaction } : {}
+      ...o.bizTransaction ? { bizTransaction: o.bizTransaction } : {},
+      /* 약속해 둔 자리·시각창 — 이것이 빠져서 야드 트윈이 재기동마다 첫 틱에 죽었다(§dockDoor). */
+      ...o.dockDoor ? { dockDoor: o.dockDoor } : {},
+      ...o.windowStartMs !== void 0 ? { windowStartMs: o.windowStartMs } : {}
     });
   }
   // ── 내부 mechanics ─────────────────────────────────────────────────────────
@@ -5250,6 +5316,8 @@ var YmsKernel = class extends FlowEngine {
   // 트레일러 epc → 화물 SSCC(하차 전 opaque / 상차 예약분)
   apptMode = /* @__PURE__ */ new Map();
   // orderId → 상하차 모드(생성 시 캡처)
+  /** 도어를 못 찾아 대기시킨 오더 — 같은 말을 매 틱 반복하지 않기 위한 표시(§allocate). */
+  doorWarned = /* @__PURE__ */ new Set();
   /** 야드 운영 정책(상하차 방식). 기본 drop(야드 버퍼). live 는 게이트/도크 직행. */
   mode;
   constructor(tenantId, policy = firstFitPolicy, mode = "drop") {
@@ -5321,7 +5389,16 @@ var YmsKernel = class extends FlowEngine {
     const trailer = this.items.get(o.allocated[0]);
     if (!trailer) return;
     if (this.clockMs < (o.windowStartMs ?? 0)) return;
-    const door = this.locations.get(o.dockDoor);
+    const door = o.dockDoor ? this.locations.get(o.dockDoor) : void 0;
+    if (!door) {
+      if (!this.doorWarned.has(o.id)) {
+        this.doorWarned.add(o.id);
+        console.warn(
+          `[yms-kernel] order "${o.id}" waits: ${o.dockDoor ? `its dock door "${o.dockDoor}" is not in this model` : "no dock door was assigned to it"} \u2014 the appointment cannot be scheduled until the declaration says where.`
+        );
+      }
+      return;
+    }
     const inflight = [...this.tasks.values()].some((t) => t.status !== "completed" && t.toNode === door.id);
     if (door.occupancy > 0 || inflight) return;
     const mode = this.apptMode.get(o.id) ?? "drop";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@operato/twin-kernel",
-  "version": "0.7.10",
+  "version": "0.7.12",
   "type": "module",
   "description": "Twin Domain Kernel — framework-agnostic, zero-dep (domain + sim + 3-channel contract). WMS/YMS/MES, EPCIS 2.0 · ISA-95.",
   "publishConfig": {