hoi4-agent-tools 3.0.7 → 3.0.9

package/dist/hoi4_agent_tools/gui/scenario.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { ConditionScopeBindingSchema, ConditionResultSchema } from '../core/condition-schema.js';
 import { renderDimensionViolation, RENDER_MAX_DIMENSION } from '../core/render-budget.js';
 import { ServiceError } from '../core/result.js';
 import { GUI_SCENARIO_MAX_KEYS, GUI_SCENARIO_MAX_LIST_KEYS, GUI_SCENARIO_MAX_ROWS, GUI_SCENARIO_MAX_STRING_CHARACTERS, } from './limits.js';
@@ -120,6 +121,8 @@ const GuiPreviewScenarioBodySchema = z
     visibleTimeSeconds: z.number().min(0).max(86_400).optional(),
     country: objectSchema.optional(),
     stateValues: objectSchema.optional(),
+    scopes: z.record(z.string().max(256), ConditionScopeBindingSchema).optional(),
+    conditionResults: z.array(ConditionResultSchema).max(10_000).optional(),
     variables: z.record(z.string(), z.number()).default({}),
     flags: z.record(z.string(), z.boolean()).default({}),
     lists: z.record(z.string(), z.array(objectSchema).max(10_000)).default({}),

package/dist/hoi4_agent_tools/gui/studio.js

@@ -6,6 +6,7 @@ import { compareCodeUnits, canonicalJson, deterministicId, hashCanonical, sha256
 import { DiagnosticCollector } from '../core/diagnostic-collector.js';
 import { sortDiagnostics } from '../core/diagnostics.js';
 import { CoreEngine } from '../core/engine.js';
+import { ClausewitzEvaluationDefinitions } from '../core/clausewitz-evaluation.js';
 import { assertRenderDimensions, RenderBudget, RENDER_MAX_PIXELS } from '../core/render-budget.js';
 import { ServiceError } from '../core/result.js';
 import { WorkspaceScanner } from '../core/scanner.js';
@@ -25,6 +26,8 @@ import { buildGuiSourceGraph } from './source-graph.js';
 import { assertGuiSourcePatchesSafe } from './source-patch.js';
 import { validateGuiScene, validateResolutionDrift, validateStateMatrix } from './validators.js';
 const staticGuiDefinitionPatterns = [
+    'common/scripted_triggers/**/*.txt',
+    'common/script_constants/**/*.txt',
     'common/scripted_localisation/**/*.txt',
     'common/decisions/**/*.txt',
     'common/decision_categories/**/*.txt',
@@ -672,13 +675,14 @@ export function guiArtifactProvenance(graph, kind, primaryScene, scenarioScenes
         },
     };
 }
+const sharedGuiGraphs = new WeakMap();
 export class ScriptedGuiStudio {
     engine;
     resolver;
     transactions;
     scanner;
     artifacts;
-    #graphCache = new Map();
+    #graphCache;
     constructor(engineOrResolver, transactions, scanner = new WorkspaceScanner(), artifacts = new ArtifactStore()) {
         this.engine =
             engineOrResolver instanceof CoreEngine
@@ -689,6 +693,8 @@ export class ScriptedGuiStudio {
                     ...(transactions === undefined ? {} : { transactions }),
                 });
         this.resolver = this.engine.resolver;
+        this.#graphCache = sharedGuiGraphs.get(this.engine) ?? new Map();
+        sharedGuiGraphs.set(this.engine, this.#graphCache);
         this.transactions = this.engine.transactions;
         this.scanner = this.engine.scanner;
         this.artifacts = this.engine.artifacts;
@@ -811,7 +817,7 @@ export class ScriptedGuiStudio {
         const scanned = await this.scanWindow(input.workspaceId, input.windowName, input.principal, input.signal, [placeholderScenario.language, ...explicitRelatedScenarios.map(({ language }) => language)], scenarioSpriteNames([placeholderScenario, ...explicitRelatedScenarios], generatedOptions?.textSamples));
         const generatedScenarios = generatedOptions === undefined
             ? []
-            : generateGuiPreviewScenarios(scanned.graph, input.windowName, placeholderScenario, generatedOptions);
+            : generateGuiPreviewScenarios(scanned.graph, input.windowName, placeholderScenario, generatedOptions, ClausewitzEvaluationDefinitions.build(scanned));
         const scenario = generatedScenarios[0] ?? placeholderScenario;
         const relatedScenarios = [
             ...(generatedOptions?.preservePlaceholder === true && generatedScenarios.length > 0
@@ -890,7 +896,7 @@ export class ScriptedGuiStudio {
         ], generatedOptions?.textSamples));
         const generatedScenarios = generatedOptions === undefined
             ? []
-            : generateGuiPreviewScenarios(scanned.graph, input.windowName, placeholderScenario, generatedOptions);
+            : generateGuiPreviewScenarios(scanned.graph, input.windowName, placeholderScenario, generatedOptions, ClausewitzEvaluationDefinitions.build(scanned));
         const scenario = generatedScenarios[0] ?? placeholderScenario;
         const relatedScenarios = [
             ...(generatedOptions?.preservePlaceholder === true && generatedScenarios.length > 0

package/dist/hoi4_agent_tools/mcp/server/create.js

@@ -8,7 +8,8 @@ import { registerEventTools } from '../tools/event.js';
 import { registerTechnologyTools } from '../tools/technology.js';
 import { registerProbabilityTools } from '../tools/probability.js';
 import { registerMcpResources } from '../resources/register.js';
-export const SERVER_INSTRUCTIONS = 'Use focus tools for focus trees, GUI tools for interfaces, and map tools for map data. Start unfamiliar event chains with hoi4.event_inspect. Event tools are read-only. Start technology and doctrine work with hoi4.tech_inspect. Technology tools are read-only. Start weighted AI, MTTH, random, and declared-pool analysis with hoi4.probability_inspect. Probability tools are read-only. Long GUI calls emit periodic progress heartbeats when the client requests progress. Large evidence is linked as resources.';
+import { installRequestLifecycle } from './request-lifecycle.js';
+export const SERVER_INSTRUCTIONS = 'Use focus tools for focus trees, GUI tools for interfaces, and map tools for map data. Start unfamiliar event chains with hoi4.event_inspect. Event tools are read-only. Start technology and doctrine work with hoi4.tech_inspect. Technology tools are read-only. Start weighted AI, MTTH, random, and declared-pool analysis with hoi4.probability_inspect. Probability tools are read-only. Concurrent calls queue automatically and emit periodic progress when the client requests it. Large evidence is linked as resources.';
 export function createMcpServer(engine, context = {}) {
     const server = new McpServer({
         name: PACKAGE_NAME,
@@ -18,6 +19,7 @@ export function createMcpServer(engine, context = {}) {
         capabilities: { logging: {} },
         instructions: SERVER_INSTRUCTIONS,
     });
+    installRequestLifecycle(server, engine);
     const serverContext = {
         ...context,
         resolveCurrentWorkspaceId: async (signal) => {

package/dist/hoi4_agent_tools/mcp/server/progress.js

@@ -3,11 +3,16 @@
  * common MCP clients, while still keeping notification traffic negligible for ordinary calls.
  */
 export const PROGRESS_HEARTBEAT_INTERVAL_MS = 10_000;
+const reporters = new WeakMap();
+const heartbeatOwners = new WeakSet();
 export function progressReporter(extra) {
+    const existing = reporters.get(extra);
+    if (existing !== undefined)
+        return existing;
     let latest = Number.NEGATIVE_INFINITY;
     let latestTotal = 1;
-    let latestMessage = '';
-    return {
+    let latestMessage = 'Waiting for server execution capacity';
+    const reporter = {
         signal: extra.signal,
         async report(progress, total, message) {
             extra.signal.throwIfAborted();
@@ -20,27 +25,38 @@ export function progressReporter(extra) {
             if (normalized <= latest)
                 return;
             latest = normalized;
-            await extra.sendNotification({
+            await extra
+                .sendNotification({
                 method: 'notifications/progress',
                 params: { progressToken, progress: normalized, total, message },
-            });
+            })
+                .catch(() => undefined);
         },
         async pulse(message = latestMessage) {
             extra.signal.throwIfAborted();
             const progressToken = extra._meta?.progressToken;
             if (progressToken === undefined)
                 return;
-            await extra.sendNotification({
+            // Use the next representably larger value rather than repeating a value, which
+            // violates MCP progress ordering. These pulses do not invent completed work.
+            latest = Number.isFinite(latest)
+                ? latest + Math.max(1, Math.abs(latest)) * Number.EPSILON * 2
+                : 0;
+            await extra
+                .sendNotification({
                 method: 'notifications/progress',
                 params: {
                     progressToken,
-                    progress: Number.isFinite(latest) ? latest : 0,
-                    total: latestTotal,
+                    progress: latest,
+                    ...(latest <= latestTotal ? { total: latestTotal } : {}),
                     message,
                 },
-            });
+            })
+                .catch(() => undefined);
         },
     };
+    reporters.set(extra, reporter);
+    return reporter;
 }
 /**
  * Keep an MCP request alive while a domain service is in a long, opaque asynchronous stage.
@@ -52,6 +68,10 @@ export async function withProgressHeartbeat(operation, reporter, message, interv
         throw new RangeError('Progress heartbeat interval must be a positive finite number');
     }
     reporter.signal.throwIfAborted();
+    if (heartbeatOwners.has(reporter)) {
+        return typeof operation === 'function' ? operation() : operation;
+    }
+    heartbeatOwners.add(reporter);
     let active = true;
     let inFlight = false;
     const tick = () => {
@@ -76,5 +96,6 @@ export async function withProgressHeartbeat(operation, reporter, message, interv
     finally {
         active = false;
         clearInterval(timer);
+        heartbeatOwners.delete(reporter);
     }
 }

package/dist/hoi4_agent_tools/mcp/server/request-lifecycle.js

@@ -0,0 +1,14 @@
+import { progressReporter, withProgressHeartbeat } from './progress.js';
+/** Wrap the public SDK handler registration so optional tools receive the same lifecycle. */
+export function installRequestLifecycle(server, engine) {
+    const register = server.server.setRequestHandler.bind(server.server);
+    const owner = {};
+    server.server.setRequestHandler = (schema, handler) => {
+        register(schema, (request, extra) => {
+            if (request.method !== 'tools/call')
+                return handler(request, extra);
+            const progress = progressReporter(extra);
+            return withProgressHeartbeat(() => engine.requests.run(owner, Buffer.byteLength(JSON.stringify(request)), extra.signal, () => engine.sharedRequests.run(extra.signal, async () => handler(request, extra))), progress);
+        });
+    };
+}

package/dist/hoi4_agent_tools/mcp/transports/bounded-stdio.js

@@ -49,6 +49,9 @@ export class BoundedStdioServerTransport {
     frameBytes = 0;
     started = false;
     closed = false;
+    writing = false;
+    queuedBytes = 0;
+    writes = [];
     constructor(options = {}) {
         this.input = options.stdin ?? process.stdin;
         this.output = options.stdout ?? process.stdout;
@@ -149,8 +152,13 @@ export class BoundedStdioServerTransport {
         this.input.off('error', this.handleInputError);
         this.input.off('end', this.handleInputEnd);
         this.input.off('close', this.handleInputClose);
-        this.output.off('error', this.handleOutputError);
+        if (!this.writing)
+            this.output.off('error', this.handleOutputError);
         this.output.off('close', this.handleOutputClose);
+        const error = new Error('Stdio transport is closed');
+        for (const write of this.writes.splice(0))
+            write.reject(error);
+        this.queuedBytes = 0;
         if (destroyInput)
             this.input.destroy();
         else if (this.input.listenerCount('data') === 0)
@@ -179,22 +187,44 @@ export class BoundedStdioServerTransport {
     send(message) {
         if (this.closed)
             return Promise.reject(new Error('Stdio transport is closed'));
+        const data = serializeMessage(message);
+        const bytes = Buffer.byteLength(data);
+        if (bytes > 134_217_728 - this.queuedBytes) {
+            return Promise.reject(new Error('Stdio output queue is full'));
+        }
         return new Promise((resolve, reject) => {
-            const onError = (error) => {
-                this.output.off('error', onError);
-                reject(error);
-            };
-            this.output.once('error', onError);
-            const written = this.output.write(serializeMessage(message));
-            if (written) {
-                this.output.off('error', onError);
-                resolve();
+            this.queuedBytes += bytes;
+            this.writes.push({ data, bytes, resolve, reject });
+            this.flushWrites();
+        });
+    }
+    flushWrites() {
+        if (this.writing || this.closed)
+            return;
+        const write = this.writes[0];
+        if (write === undefined)
+            return;
+        this.writing = true;
+        this.output.write(write.data, (error) => {
+            this.writing = false;
+            if (this.closed) {
+                // A stream error is emitted after its write callback. Keep the listener through
+                // that turn so closing an output with buffered writes cannot crash the process.
+                setImmediate(() => this.output.off('error', this.handleOutputError));
+                return;
+            }
+            this.writes.shift();
+            this.queuedBytes -= write.bytes;
+            if (error != null) {
+                write.reject(error);
+                this.writing = true;
+                this.finish(true);
+                this.writing = false;
+                setImmediate(() => this.output.off('error', this.handleOutputError));
             }
             else {
-                this.output.once('drain', () => {
-                    this.output.off('error', onError);
-                    resolve();
-                });
+                write.resolve();
+                this.flushWrites();
             }
         });
     }

package/dist/hoi4_agent_tools/mcp/transports/http.js

@@ -5,6 +5,7 @@ import express, {} from 'express';
 import { hostHeaderValidation } from '@modelcontextprotocol/sdk/server/middleware/hostHeaderValidation.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { isInitializeRequest, SUPPORTED_PROTOCOL_VERSIONS, } from '@modelcontextprotocol/sdk/types.js';
+import { HTTP_MAX_AGGREGATE_BODY_BYTES } from '../../core/configuration.js';
 import { canonicalJson } from '../../core/canonical.js';
 import { authenticate, bearerChallenge, HttpAuthError, protectedResourceMetadata, validateHttpDeployment, } from '../security/auth.js';
 import { BoundedEventStore, SharedEventStoreBudget } from './event-store.js';
@@ -346,18 +347,39 @@ export async function startHttpServer(engine, configuration, serverFactory) {
     const rates = new Map();
     let lastRatePruneMinute = -1;
     let concurrent = 0;
+    let reservedBodyBytes = 0;
     const admissionMiddleware = (request, response, next) => {
-        if (concurrent >= http.maxConcurrentRequests) {
+        // Reserve a few small envelopes for cancellation, roots replies, and discovery,
+        // even when all long request slots are occupied.
+        const declaredLength = request.headers['content-length'];
+        const bodyBytes = request.method === 'POST'
+            ? declaredLength === undefined
+                ? http.maxBodyBytes
+                : Number(declaredLength)
+            : 0;
+        if (!Number.isSafeInteger(bodyBytes) || bodyBytes < 0 || bodyBytes > http.maxBodyBytes) {
+            jsonRpcError(response, 413, 'Payload too large');
+            return;
+        }
+        const overflow = concurrent >= http.maxConcurrentRequests;
+        if (overflow && (concurrent >= http.maxConcurrentRequests + 16 || bodyBytes > 65_536)) {
             response.status(429).setHeader('Retry-After', '1').json({ error: 'concurrency_limit' });
             return;
         }
+        if (bodyBytes > HTTP_MAX_AGGREGATE_BODY_BYTES - reservedBodyBytes) {
+            response.status(429).setHeader('Retry-After', '1').json({ error: 'body_capacity_limit' });
+            return;
+        }
         concurrent += 1;
+        reservedBodyBytes += bodyBytes;
+        response.locals.admissionOverflow = overflow;
         let released = false;
         const release = () => {
             if (released)
                 return;
             released = true;
             concurrent = Math.max(0, concurrent - 1);
+            reservedBodyBytes -= bodyBytes;
         };
         response.once('finish', release);
         response.once('close', release);
@@ -387,6 +409,8 @@ export async function startHttpServer(engine, configuration, serverFactory) {
         }
         next();
     };
+    app.post('/mcp', requireMcpJsonContentType);
+    app.post('/mcp', requireIdentityContentEncoding);
     app.use(admissionMiddleware);
     const authenticateMiddleware = async (request, response, next) => {
         try {
@@ -427,8 +451,6 @@ export async function startHttpServer(engine, configuration, serverFactory) {
     // Supplying a defined parsed body to handleRequest prevents the SDK from falling back to
     // an unbounded Request.json() parse for alternate media types or empty established-session
     // requests. GET and DELETE deliberately remain bodyless.
-    app.post('/mcp', requireMcpJsonContentType);
-    app.post('/mcp', requireIdentityContentEncoding);
     app.post('/mcp', express.json({
         limit: http.maxBodyBytes,
         strict: true,
@@ -437,6 +459,24 @@ export async function startHttpServer(engine, configuration, serverFactory) {
         verify: verifyMcpUtf8,
     }));
     app.post('/mcp', requireParsedMcpJsonBody);
+    app.post('/mcp', (request, response, next) => {
+        const method = isRecord(request.body) ? request.body.method : undefined;
+        const control = method === undefined ||
+            (typeof method === 'string' &&
+                (method.startsWith('notifications/') ||
+                    [
+                        'ping',
+                        'tools/list',
+                        'resources/list',
+                        'resources/templates/list',
+                        'prompts/list',
+                    ].includes(method)));
+        if (response.locals.admissionOverflow === true && !control) {
+            response.status(429).setHeader('Retry-After', '1').json({ error: 'concurrency_limit' });
+            return;
+        }
+        next();
+    });
     if (http.oauth !== undefined && http.publicUrl !== undefined) {
         const metadata = protectedResourceMetadata(configuration);
         app.get('/.well-known/oauth-protected-resource', (_request, response) => response.json(metadata));
@@ -449,6 +489,8 @@ export async function startHttpServer(engine, configuration, serverFactory) {
     let eventStreams = 0;
     const eventStreamsByPrincipal = new Map();
     const sessionTtlMs = http.sessionTtlSeconds * 1000;
+    const sessionExpired = (session) => session.credentialExpiresAt <= Date.now() ||
+        (session.activeRequests === 0 && session.expiresAt <= Date.now());
     const removeSession = async (sessionId) => {
         const session = sessions.get(sessionId);
         if (session === undefined)
@@ -463,13 +505,21 @@ export async function startHttpServer(engine, configuration, serverFactory) {
     const scheduleSessionExpiry = (sessionId, session) => {
         if (session.expiryTimer !== undefined)
             clearTimeout(session.expiryTimer);
-        session.expiryTimer = setTimeout(() => void removeSession(sessionId), Math.max(0, session.expiresAt - Date.now()));
+        session.expiryTimer = setTimeout(() => {
+            if (sessionExpired(session))
+                void removeSession(sessionId);
+            else {
+                session.expiresAt = Math.min(Date.now() + sessionTtlMs, session.credentialExpiresAt);
+                scheduleSessionExpiry(sessionId, session);
+            }
+        }, Math.max(0, session.expiresAt - Date.now()));
         session.expiryTimer.unref();
     };
     const pruneExpiredSessions = async () => {
         const now = Date.now();
         await Promise.all([...sessions]
-            .filter(([, session]) => session.expiresAt <= now)
+            .filter(([, session]) => session.credentialExpiresAt <= now ||
+            (session.activeRequests === 0 && session.expiresAt <= now))
             .map(([sessionId]) => removeSession(sessionId)));
     };
     const findSession = async (request, response) => {
@@ -479,7 +529,7 @@ export async function startHttpServer(engine, configuration, serverFactory) {
             return undefined;
         }
         const session = sessions.get(id);
-        if (session === undefined || session.expiresAt <= Date.now()) {
+        if (session === undefined || sessionExpired(session)) {
             if (session !== undefined)
                 await removeSession(id);
             jsonRpcError(response, 404, 'Unknown or expired MCP session');
@@ -504,6 +554,22 @@ export async function startHttpServer(engine, configuration, serverFactory) {
         session.scopes = expandedScopes;
         session.authorizationContext.scopes = expandedScopes;
         session.expiresAt = boundedSessionExpiration(principal, Date.now(), sessionTtlMs);
+        session.credentialExpiresAt =
+            principal.expiresAt === undefined ? Infinity : principal.expiresAt * 1000;
+        session.activeRequests += 1;
+        let requestFinished = false;
+        const finishRequest = () => {
+            if (requestFinished)
+                return;
+            requestFinished = true;
+            session.activeRequests -= 1;
+            if (sessions.get(id) !== session)
+                return;
+            session.expiresAt = Math.min(Date.now() + sessionTtlMs, session.credentialExpiresAt);
+            scheduleSessionExpiry(id, session);
+        };
+        response.once('finish', finishRequest);
+        response.once('close', finishRequest);
         scheduleSessionExpiry(id, session);
         return session;
     };
@@ -569,6 +635,8 @@ export async function startHttpServer(engine, configuration, serverFactory) {
                             credentialId: principal.credentialId,
                             scopes: [...principal.scopes],
                             authorizationContext,
+                            activeRequests: 0,
+                            credentialExpiresAt: principal.expiresAt === undefined ? Infinity : principal.expiresAt * 1000,
                             expiresAt: Math.min(initialExpiration, boundedSessionExpiration(principal, Date.now(), sessionTtlMs)),
                         };
                         sessions.set(newId, session);
@@ -718,7 +786,7 @@ export async function startHttpServer(engine, configuration, serverFactory) {
     process.stderr.write(`${canonicalJson({ level: 'info', event: 'http_listening', url })}\n`);
     const cleanup = setInterval(() => {
         for (const [sessionId, session] of sessions) {
-            if (session.expiresAt <= Date.now())
+            if (sessionExpired(session))
                 void removeSession(sessionId);
         }
     }, Math.min(60_000, sessionTtlMs));

package/dist/hoi4_agent_tools/probability/scenario-state.js

@@ -1,98 +1,5 @@
-function caseInsensitiveEntry(record, key) {
-    if (record === undefined)
-        return undefined;
-    if (Object.hasOwn(record, key))
-        return record[key];
-    const normalized = key.toLowerCase();
-    const found = Object.entries(record).find(([candidate]) => candidate.toLowerCase() === normalized);
-    return found?.[1];
-}
-export function rootScopeContext(scenario) {
-    return {
-        expression: 'ROOT',
-        binding: {
-            id: scenario.actor ?? 'ROOT',
-            ...(scenario.actor === undefined ? {} : { actor: scenario.actor }),
-            state: scenario.state,
-            ...(scenario.flags === undefined ? {} : { flags: scenario.flags }),
-            ...(scenario.eventTargets === undefined ? {} : { eventTargets: scenario.eventTargets }),
-        },
-    };
-}
-function explicitScope(scenario, expression, parent) {
-    const binding = caseInsensitiveEntry(scenario.scopes, expression);
-    return binding === undefined ? undefined : { expression, binding, parent };
-}
-export function resolveScopeContext(scenario, expression, current) {
-    const upper = expression.toUpperCase();
-    if (upper === 'ROOT')
-        return rootScopeContext(scenario);
-    if (upper === 'THIS')
-        return current;
-    if (upper === 'PREV')
-        return current.parent ?? rootScopeContext(scenario);
-    const chained = current.expression === 'ROOT' || current.expression === 'THIS'
-        ? expression
-        : `${current.expression}.${expression}`;
-    const chainedBinding = explicitScope(scenario, chained, current);
-    if (chainedBinding !== undefined)
-        return chainedBinding;
-    const direct = explicitScope(scenario, expression, current);
-    if (direct !== undefined)
-        return direct;
-    const targetMatch = /^(?:event_target|scope):(.+)$/iu.exec(expression);
-    const targetId = targetMatch === null
-        ? undefined
-        : (caseInsensitiveEntry(current.binding.eventTargets, targetMatch[1]) ??
-            caseInsensitiveEntry(scenario.eventTargets, targetMatch[1]));
-    if (targetId !== undefined) {
-        const declaredBinding = Object.values(scenario.scopes ?? {}).find((binding) => binding.id === targetId || binding.actor === targetId);
-        return {
-            expression,
-            binding: declaredBinding ?? { id: targetId, actor: targetId, state: {} },
-            parent: current,
-        };
-    }
-    return undefined;
-}
-export function scopeStateValue(scenario, key, current) {
-    if (Object.hasOwn(current.binding.state, key))
-        return current.binding.state[key];
-    if (Object.hasOwn(current.binding.state, `trigger.${key}`))
-        return current.binding.state[`trigger.${key}`];
-    if (current.expression !== 'ROOT')
-        return undefined;
-    if (Object.hasOwn(scenario.state, key))
-        return scenario.state[key];
-    if (Object.hasOwn(scenario.state, `trigger.${key}`))
-        return scenario.state[`trigger.${key}`];
-    return undefined;
-}
-export function rootStateValue(scenario, key) {
-    if (Object.hasOwn(scenario.state, key))
-        return scenario.state[key];
-    if (Object.hasOwn(scenario.state, `trigger.${key}`))
-        return scenario.state[`trigger.${key}`];
-    return undefined;
-}
-export function scopeIdentity(current) {
-    return current.binding.actor ?? current.binding.id;
-}
-export function scopedExpressionValue(scenario, expression) {
-    const scopes = Object.entries(scenario.scopes ?? {}).sort(([left], [right]) => right.length - left.length);
-    for (const [scope, binding] of scopes) {
-        for (const prefix of [`${scope}.`, `scope.${scope}.`, `scopes.${scope}.`]) {
-            if (!expression.toLowerCase().startsWith(prefix.toLowerCase()))
-                continue;
-            const key = expression.slice(prefix.length).replace(/^state\./u, '');
-            if (Object.hasOwn(binding.state, key))
-                return binding.state[key];
-            if (Object.hasOwn(binding.state, `variable.${key}`))
-                return binding.state[`variable.${key}`];
-        }
-    }
-    return undefined;
-}
+import { rootStateValue, scopedExpressionValue } from '../core/scenario-state.js';
+export { rootScopeContext, resolveScopeContext, scopeStateValue, rootStateValue, scopeIdentity, scopedExpressionValue, } from '../core/scenario-state.js';
 function updateScopeState(scenario, path, value) {
     const scopes = Object.entries(scenario.scopes ?? {}).sort(([left], [right]) => right.length - left.length);
     for (const [scope, binding] of scopes) {