@operato/twin-kernel 0.7.9 → 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/forecast.d.ts

@@ -35,3 +35,22 @@ export interface MonteCarloOptions {
  * run 마다 fork(현재 보존) + scenario.load(seed+i)(미래 변주) + horizon 까지 구동. 원본 무간섭.
  */
 export declare function monteCarloForecast(twin: ForecastTwin, opts: MonteCarloOptions): MonteCarloResult;
+/**
+ * 같은 예측을, **회차 사이에 자리를 내주면서** 계산한다.
+ *
+ * ── 왜 필요한가 (2026-08-17 실측) ───────────────────────────────────────────
+ * 이 예측은 호출한 쪽의 이벤트 루프에서 **동기로** 돈다. 실측으로 트윈 하나의 예측 한 번이
+ * 30회차 × 300틱 = 9,000틱, 한 틱 3.2ms → **28.5초**였다. 그동안 그 프로세스의 라이브 트윈도,
+ * HTTP 도, 구독도 전부 멈춘다 — 예측 한 번에 시스템 전체가 정지한다.
+ *
+ * 총 시간은 이 함수로 줄지 않는다(그건 틱 수를 줄이는 다른 일이다). 줄어드는 것은 **한 번에
+ * 붙잡는 시간**이다. 회차 하나가 끝날 때마다 자리를 내주면 그 사이에 틱과 요청이 지나간다.
+ *
+ * 양보 방법은 **호출자가 준다.** 커널은 실행 환경을 모른다(`setImmediate` 는 서버 런타임의 것이다).
+ * 주지 않으면 마이크로태스크로 떨어지는데, 그것은 I/O 에 자리를 내주지 못하므로 **얼어붙는 증상은
+ * 그대로**다 — 그래서 기본값에 기대지 말고 호출자가 명시하는 것이 맞다.
+ */
+export declare function monteCarloForecastAsync(twin: ForecastTwin, opts: MonteCarloOptions & {
+    yieldFn?: () => Promise<void>;
+    yieldEveryTicks?: number;
+}): Promise<MonteCarloResult>;

package/dist/forecast.js

@@ -18,14 +18,9 @@ function clockOf(twin) {
  */
 export function monteCarloForecast(twin, opts) {
     const now = clockOf(twin);
-    const step = opts.tickMs ?? 1000;
-    const baseSeed = opts.scenario.seed ?? 1;
     const samples = [];
     for (let i = 0; i < opts.runs; i++) {
-        const fc = twin.fork();
-        fc.scenario.load({ ...opts.scenario, seed: baseSeed + i }); // 미래만 변주(현재 상태는 fork 로 보존)
-        fc.scenario.start();
-        const target = now + opts.horizonMs;
+        const { fc, step, target } = startRun(twin, opts, now, i);
         let guard = 0;
         while (clockOf(fc) < target && guard++ < 1_000_000)
             fc.tick(step);
@@ -33,6 +28,61 @@ export function monteCarloForecast(twin, opts) {
     }
     return summarize(opts.runs, samples);
 }
+/**
+ * 한 회차의 **출발점** — fork(현재 보존) + 그 회차의 미래(seed 변주).
+ *
+ * 동기·비동기 두 진입점이 이것을 함께 쓴다. 구동 루프는 각자 쓰지만(하나는 중간에 await 한다),
+ * **표본이 무엇이 되는지를 정하는 규칙**(어디서 갈라져 어떤 seed 로 도는가)은 여기 한 곳이다.
+ * 그것이 갈라지면 같은 seed 가 다른 수를 내고, 그때는 어느 쪽이 옳은지 가릴 방법이 없다.
+ */
+function startRun(twin, opts, nowMs, i) {
+    const fc = twin.fork();
+    fc.scenario.load({ ...opts.scenario, seed: (opts.scenario.seed ?? 1) + i }); // 미래만 변주(현재 상태는 fork 로 보존)
+    fc.scenario.start();
+    return { fc, step: opts.tickMs ?? 1000, target: nowMs + opts.horizonMs };
+}
+/**
+ * 같은 예측을, **회차 사이에 자리를 내주면서** 계산한다.
+ *
+ * ── 왜 필요한가 (2026-08-17 실측) ───────────────────────────────────────────
+ * 이 예측은 호출한 쪽의 이벤트 루프에서 **동기로** 돈다. 실측으로 트윈 하나의 예측 한 번이
+ * 30회차 × 300틱 = 9,000틱, 한 틱 3.2ms → **28.5초**였다. 그동안 그 프로세스의 라이브 트윈도,
+ * HTTP 도, 구독도 전부 멈춘다 — 예측 한 번에 시스템 전체가 정지한다.
+ *
+ * 총 시간은 이 함수로 줄지 않는다(그건 틱 수를 줄이는 다른 일이다). 줄어드는 것은 **한 번에
+ * 붙잡는 시간**이다. 회차 하나가 끝날 때마다 자리를 내주면 그 사이에 틱과 요청이 지나간다.
+ *
+ * 양보 방법은 **호출자가 준다.** 커널은 실행 환경을 모른다(`setImmediate` 는 서버 런타임의 것이다).
+ * 주지 않으면 마이크로태스크로 떨어지는데, 그것은 I/O 에 자리를 내주지 못하므로 **얼어붙는 증상은
+ * 그대로**다 — 그래서 기본값에 기대지 말고 호출자가 명시하는 것이 맞다.
+ */
+export async function monteCarloForecastAsync(twin, opts) {
+    const now = clockOf(twin);
+    const yieldFn = opts.yieldFn ?? (() => Promise.resolve());
+    /*
+     * **회차 사이만 내주면 부족하다.** 회차 하나가 300틱 × 3.2ms ≈ 1초라, 그동안 들어온 요청은 그만큼
+     * 기다린다(실측 응답 3초). 그래서 틱 몇 개마다도 끊는다 — 기본값은 라이브 틱 간격(1초)보다 훨씬
+     * 짧게 잡아, 트윈이 한 박자도 밀리지 않을 크기로 둔다.
+     */
+    const everyTicks = Math.max(1, opts.yieldEveryTicks ?? 50);
+    const samples = [];
+    for (let i = 0; i < opts.runs; i++) {
+        const { fc, step, target } = startRun(twin, opts, now, i);
+        let guard = 0;
+        let sinceYield = 0;
+        while (clockOf(fc) < target && guard++ < 1_000_000) {
+            fc.tick(step);
+            if (++sinceYield >= everyTicks) {
+                sinceYield = 0;
+                await yieldFn();
+            }
+        }
+        samples.push(opts.metric(fc.getSnapshot()));
+        if (i < opts.runs - 1)
+            await yieldFn();
+    }
+    return summarize(opts.runs, samples);
+}
 function summarize(runs, samples) {
     const sorted = [...samples].sort((a, b) => a - b);
     const pct = (p) => sorted[Math.min(sorted.length - 1, Math.floor(p * sorted.length))];

package/dist-cjs/index.cjs

@@ -122,6 +122,7 @@ __export(index_exports, {
   meetsTests: () => meetsTests,
   minuteOfDayAt: () => minuteOfDayAt,
   monteCarloForecast: () => monteCarloForecast,
+  monteCarloForecastAsync: () => monteCarloForecastAsync,
   objectEvent: () => objectEvent,
   offCalendarAt: () => offCalendarAt,
   offCalendarReasonAt: () => offCalendarReasonAt,
@@ -260,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 ?? []];
@@ -408,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;
@@ -434,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);
@@ -730,20 +762,42 @@ function clockOf2(twin) {
 }
 function monteCarloForecast(twin, opts) {
   const now = clockOf2(twin);
-  const step = opts.tickMs ?? 1e3;
-  const baseSeed = opts.scenario.seed ?? 1;
   const samples = [];
   for (let i = 0; i < opts.runs; i++) {
-    const fc = twin.fork();
-    fc.scenario.load({ ...opts.scenario, seed: baseSeed + i });
-    fc.scenario.start();
-    const target = now + opts.horizonMs;
+    const { fc, step, target } = startRun(twin, opts, now, i);
     let guard = 0;
     while (clockOf2(fc) < target && guard++ < 1e6) fc.tick(step);
     samples.push(opts.metric(fc.getSnapshot()));
   }
   return summarize(opts.runs, samples);
 }
+function startRun(twin, opts, nowMs, i) {
+  const fc = twin.fork();
+  fc.scenario.load({ ...opts.scenario, seed: (opts.scenario.seed ?? 1) + i });
+  fc.scenario.start();
+  return { fc, step: opts.tickMs ?? 1e3, target: nowMs + opts.horizonMs };
+}
+async function monteCarloForecastAsync(twin, opts) {
+  const now = clockOf2(twin);
+  const yieldFn = opts.yieldFn ?? (() => Promise.resolve());
+  const everyTicks = Math.max(1, opts.yieldEveryTicks ?? 50);
+  const samples = [];
+  for (let i = 0; i < opts.runs; i++) {
+    const { fc, step, target } = startRun(twin, opts, now, i);
+    let guard = 0;
+    let sinceYield = 0;
+    while (clockOf2(fc) < target && guard++ < 1e6) {
+      fc.tick(step);
+      if (++sinceYield >= everyTicks) {
+        sinceYield = 0;
+        await yieldFn();
+      }
+    }
+    samples.push(opts.metric(fc.getSnapshot()));
+    if (i < opts.runs - 1) await yieldFn();
+  }
+  return summarize(opts.runs, samples);
+}
 function summarize(runs, samples) {
   const sorted = [...samples].sort((a, b) => a - b);
   const pct = (p) => sorted[Math.min(sorted.length - 1, Math.floor(p * sorted.length))];
@@ -3598,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`.
    *
@@ -6516,6 +6589,7 @@ function retiredVocabularyIn(line) {
   meetsTests,
   minuteOfDayAt,
   monteCarloForecast,
+  monteCarloForecastAsync,
   objectEvent,
   offCalendarAt,
   offCalendarReasonAt,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@operato/twin-kernel",
-  "version": "0.7.9",
+  "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": {