@operato/twin-kernel 0.7.10 → 0.7.11

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` =

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

@@ -1062,7 +1062,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`.
      *

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);
@@ -3621,9 +3652,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`.
    *

package/package.json

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