@intent-framework/core 0.1.0-alpha.0 → 0.1.0-alpha.10

package/README.md

@@ -0,0 +1,67 @@
+# @intent-framework/core
+
+Platformless semantic graph and runtime for Intent applications.
+
+## Install
+
+```sh
+pnpm add @intent-framework/core
+```
+
+```sh
+npm install @intent-framework/core
+```
+
+## What it provides
+
+- `screen()` — define a semantic interaction space
+- `$.state.text()` / `$.state.boolean()` / `$.state.choice()` — reactive state
+- `$.ask()` — user-facing question with validation
+- `$.act()` — executable action with conditions, lifecycle, and feedback
+- `$.resource()` — async state with load/reload lifecycle
+- `$.surface()` — named containment surface
+- `createScreenRuntime()` — runtime that owns screen state and resources
+- `inspectScreen()` — semantic graph snapshot with diagnostics
+- Condition and signal primitives
+
+## Minimal example
+
+```ts
+import { screen, inspectScreen } from "@intent-framework/core"
+
+const InviteMember = screen("InviteMember", $ => {
+  const email = $.state.text("email")
+
+  const emailAsk = $.ask("Email", email)
+    .required("Email is required")
+    .validate(value => value.includes("@") ? true : "Enter a valid email")
+
+  const invite = $.act("Invite member")
+    .primary()
+    .when(emailAsk.valid, "Enter a valid email first")
+    .does(() => {
+      console.log("invite", email.value)
+    })
+
+  $.surface("main").contains(emailAsk, invite)
+})
+
+const graph = inspectScreen(InviteMember)
+console.log(graph.diagnostics)
+```
+
+## Where this fits
+
+Core defines the product graph. It has no DOM, React, Node, or framework dependencies. Renderers (`@intent-framework/dom`), the router (`@intent-framework/router`), and testing (`@intent-framework/testing`) all build on core.
+
+## Learn more
+
+- [Root README](../../README.md) — project overview and philosophy
+- [Quickstart](../../docs/Quickstart.md) — step-by-step guide
+- [Inspect Screen and Diagnostics Guide](../../docs/Inspect-Screen.md) — graph inspection and diagnostics
+- [Resources Guide](../../docs/Resources.md) — resource lifecycle and runtime scoping
+- [MVP Checkpoint](../../docs/MVP-Checkpoint.md) — current implementation boundaries
+
+## Status
+
+Experimental alpha. APIs may change. Not recommended for production use.

package/dist/graph.d.ts

@@ -2,16 +2,24 @@ import type { ScreenDefinition } from "./screen.js";
 import type { DefaultScreenServices } from "./act.js";
 import type { AnyResourceNode } from "./resource.js";
 export type DiagnosticSeverity = "info" | "warning" | "error";
+export type FlowDiagnosticMeta = {
+    flowNodeId: string;
+    flowSemanticNodeId?: string;
+};
 export type GraphDiagnostic = {
     severity: DiagnosticSeverity;
     code: string;
     message: string;
     nodeId?: string;
+    semanticNodeId?: string;
+    flow?: FlowDiagnosticMeta;
 };
 export type InspectedScreen = {
     name: string;
+    semanticId: string;
     asks: Array<{
         id: string;
+        semanticId: string;
         label: string;
         kind: string;
         required: boolean;
@@ -21,6 +29,7 @@ export type InspectedScreen = {
     }>;
     acts: Array<{
         id: string;
+        semanticId: string;
         label: string;
         primary: boolean;
         enabled: boolean;
@@ -31,16 +40,19 @@ export type InspectedScreen = {
     }>;
     flows: Array<{
         id: string;
+        semanticId: string;
         name: string;
         stepCount: number;
     }>;
     surfaces: Array<{
         id: string;
+        semanticId: string;
         name: string;
         itemCount: number;
     }>;
     resources: Array<{
         id: string;
+        semanticId: string;
         name: string;
         status: string;
         hasValue: boolean;

package/dist/index.d.ts

@@ -1,13 +1,13 @@
 export { screen } from "./screen.js";
 export type { ScreenDefinition, ScreenBuilder } from "./screen.js";
 export { inspectScreen } from "./graph.js";
-export type { InspectedScreen, GraphDiagnostic, DiagnosticSeverity } from "./graph.js";
+export type { InspectedScreen, GraphDiagnostic, DiagnosticSeverity, FlowDiagnosticMeta } from "./graph.js";
 export type { TextState, BooleanState, ChoiceState } from "./state.js";
 export type { AskNode, AnyAskNode, AskKind, AskBuilder } from "./ask.js";
 export type { ActNode, ActCondition, ActStatus, FeedbackConfig, ActBuilder, NavigationService, ActionExecutionContext, DefaultScreenServices } from "./act.js";
 export type { FlowNode, FlowStep, FlowBuilder } from "./flow.js";
 export type { SurfaceNode, SurfaceBuilder } from "./surface.js";
-export type { ResourceNode, ResourceConfig, ResourceLoadContext, ResourceStatus, AnyResourceNode } from "./resource.js";
+export type { ResourceNode, ResourceConfig, ResourceCacheOptions, ResourceLoadContext, ResourceStatus, ResourceKey, AnyResourceNode } from "./resource.js";
 export { ResourceRef, createResourceNode } from "./resource.js";
 export { createScreenRuntime } from "./runtime.js";
 export type { ScreenRuntime } from "./runtime.js";

package/dist/index.js

@@ -37,9 +37,25 @@ function signal(initial) {
 
 //#endregion
 //#region src/resource.ts
-function createResourceNode(id, name, loader, autoLoad = true) {
+function createResourceNode(id, name, loader, autoLoad = true, cache) {
 	const statusSignal = signal(0);
 	const staleSignal = signal(0);
+	const hasKey = typeof cache?.key === "function";
+	const DEFAULT_KEY = "";
+	function createEntry() {
+		return {
+			value: void 0,
+			status: "idle",
+			error: void 0,
+			stale: false,
+			staleTimer: null,
+			cacheTimer: null,
+			inFlightPromise: null
+		};
+	}
+	const entries = /* @__PURE__ */ new Map();
+	let _activeKey = DEFAULT_KEY;
+	if (!hasKey) entries.set(DEFAULT_KEY, createEntry());
 	let currentStatus = "idle";
 	let currentValue = void 0;
 	let currentError = void 0;
@@ -47,10 +63,94 @@ function createResourceNode(id, name, loader, autoLoad = true) {
 	let lastContext = void 0;
 	const notify = () => statusSignal.set(statusSignal.get() + 1);
 	const staleNotify = () => staleSignal.set(staleSignal.get() + 1);
+	const shouldDeduplicate = cache ? cache.deduplicate !== false : false;
 	let _ready;
 	let _pending;
 	let _failed;
 	let _stale;
+	function getActiveEntry() {
+		let entry = entries.get(_activeKey);
+		if (!entry) {
+			entry = createEntry();
+			entries.set(_activeKey, entry);
+		}
+		return entry;
+	}
+	function syncFromEntry(entry) {
+		currentStatus = entry.status;
+		currentValue = entry.value;
+		currentError = entry.error;
+		if (currentStale !== entry.stale) {
+			currentStale = entry.stale;
+			staleNotify();
+		}
+		notify();
+	}
+	function syncFromActiveEntry() {
+		syncFromEntry(getActiveEntry());
+	}
+	function encodeResourceKey(key) {
+		if (Array.isArray(key)) return ["array", key.map(encodeResourceKey)];
+		if (key === null) return ["null"];
+		if (key === void 0) return ["undefined"];
+		if (typeof key === "string") return ["string", key];
+		if (typeof key === "boolean") return ["boolean", key];
+		if (typeof key === "number") {
+			if (Number.isNaN(key)) return ["number", "NaN"];
+			if (key === Infinity) return ["number", "Infinity"];
+			if (key === -Infinity) return ["number", "-Infinity"];
+			if (Object.is(key, -0)) return ["number", "-0"];
+			return ["number", key];
+		}
+		const exhaustive = key;
+		return exhaustive;
+	}
+	function normalizeKey(key) {
+		return JSON.stringify(encodeResourceKey(key));
+	}
+	function resolveKey(ctx) {
+		if (!hasKey) return DEFAULT_KEY;
+		const context = ctx ?? lastContext ?? {};
+		return normalizeKey(cache.key(context));
+	}
+	function _clearEntryStaleTimer(entry) {
+		if (entry.staleTimer != null) {
+			clearTimeout(entry.staleTimer);
+			entry.staleTimer = null;
+		}
+	}
+	function _startEntryStaleTimer(entry, key) {
+		_clearEntryStaleTimer(entry);
+		if (cache?.staleTime != null && isFinite(cache.staleTime)) entry.staleTimer = setTimeout(() => {
+			if (!entry.stale) {
+				entry.stale = true;
+				_startEntryCacheTimer(entry, key);
+				if (entry === getActiveEntry()) {
+					currentStale = true;
+					staleNotify();
+				}
+			}
+		}, cache.staleTime);
+	}
+	function _clearEntryCacheTimer(entry) {
+		if (entry.cacheTimer != null) {
+			clearTimeout(entry.cacheTimer);
+			entry.cacheTimer = null;
+		}
+	}
+	function _startEntryCacheTimer(entry, key) {
+		_clearEntryCacheTimer(entry);
+		if (cache?.cacheTime != null && isFinite(cache.cacheTime)) entry.cacheTimer = setTimeout(() => {
+			if (entry === getActiveEntry()) {
+				entry.value = void 0;
+				entry.error = void 0;
+				entry.status = "idle";
+				entry.stale = false;
+				_clearEntryCacheTimer(entry);
+				syncFromActiveEntry();
+			} else entries.delete(key);
+		}, cache.cacheTime);
+	}
 	function getReady() {
 		if (!_ready) _ready = createCondition(() => currentStatus === "ready", (notify$1) => statusSignal.subscribe(() => notify$1()));
 		return _ready;
@@ -67,34 +167,68 @@ function createResourceNode(id, name, loader, autoLoad = true) {
 		if (!_stale) _stale = createCondition(() => currentStale, (notify$1) => staleSignal.subscribe(() => notify$1()));
 		return _stale;
 	}
-	async function executeLoad(context) {
-		currentStale = false;
-		staleNotify();
-		currentStatus = "pending";
-		currentValue = void 0;
-		currentError = void 0;
-		notify();
+	function executeLoad(context) {
+		const key = resolveKey(context);
+		const prevActiveKey = _activeKey;
+		_activeKey = key;
+		let entry = entries.get(key);
+		if (!entry) {
+			entry = createEntry();
+			entries.set(key, entry);
+		}
+		_clearEntryCacheTimer(entry);
+		if (shouldDeduplicate && entry.inFlightPromise) {
+			if (key !== prevActiveKey) syncFromEntry(entry);
+			return entry.inFlightPromise;
+		}
 		if (context !== void 0) lastContext = context;
 		const loadContext = context ?? lastContext ?? {};
-		try {
-			const result = await Promise.resolve(loader(loadContext));
-			currentValue = result;
-			currentStatus = "ready";
-			currentStale = false;
-			notify();
-			staleNotify();
-		} catch (e) {
-			currentError = e;
-			currentStatus = "failed";
-			currentStale = false;
-			notify();
-			staleNotify();
-		}
+		entry.stale = false;
+		entry.status = "pending";
+		entry.value = void 0;
+		entry.error = void 0;
+		syncFromActiveEntry();
+		const promise = (async () => {
+			try {
+				const result = await Promise.resolve(loader(loadContext));
+				if (entries.get(key) !== entry) return;
+				entry.value = result;
+				entry.status = "ready";
+				entry.stale = false;
+				_clearEntryCacheTimer(entry);
+				if (entry === getActiveEntry()) syncFromEntry(entry);
+				staleNotify();
+				_startEntryStaleTimer(entry, key);
+			} catch (e) {
+				if (entries.get(key) !== entry) return;
+				entry.error = e;
+				entry.status = "failed";
+				entry.stale = false;
+				if (entry === getActiveEntry()) syncFromEntry(entry);
+				staleNotify();
+			} finally {
+				entry.inFlightPromise = null;
+			}
+		})();
+		entry.inFlightPromise = promise;
+		return promise;
 	}
 	function invalidate() {
-		if (!currentStale) {
-			currentStale = true;
-			staleNotify();
+		const entry = getActiveEntry();
+		if (!entry.stale) {
+			entry.stale = true;
+			_startEntryCacheTimer(entry, _activeKey);
+			if (entry === getActiveEntry()) {
+				currentStale = true;
+				staleNotify();
+			}
+		}
+	}
+	function dispose() {
+		for (const entry of entries.values()) {
+			_clearEntryStaleTimer(entry);
+			_clearEntryCacheTimer(entry);
+			entry.inFlightPromise = null;
 		}
 	}
 	const node = {
@@ -127,7 +261,8 @@ function createResourceNode(id, name, loader, autoLoad = true) {
 		invalidate,
 		subscribe(fn) {
 			return statusSignal.subscribe(fn);
-		}
+		},
+		dispose
 	};
 	return node;
 }
@@ -351,6 +486,11 @@ function getSurfaces() {
 function getResources() {
 	return resourceMap;
 }
+function nextSuffix(baseId, exists) {
+	let counter = 2;
+	while (exists(`${baseId}-${counter}`)) counter++;
+	return `${baseId}-${counter}`;
+}
 
 //#endregion
 //#region src/ask.ts
@@ -408,7 +548,9 @@ function computeAskError(node) {
 var AskBuilder = class {
 	node;
 	constructor(label, stateRef) {
-		const id = `ask_${label.toLowerCase().replace(/\s+/g, "_")}`;
+		const baseId = `ask_${label.toLowerCase().replace(/\s+/g, "_")}`;
+		const existing = getAsks();
+		const id = existing.has(baseId) ? nextSuffix(baseId, (id$1) => existing.has(id$1)) : baseId;
 		const onChange = stateRef.onChange;
 		const subscribeToState = onChange ? (fn) => onChange((_v) => fn()) : void 0;
 		this.node = createAskNode(id, label, stateRef, subscribeToState);
@@ -520,7 +662,9 @@ async function executeAct(node, context, notify) {
 var ActBuilder = class {
 	node;
 	constructor(label) {
-		const id = `act_${label.toLowerCase().replace(/\s+/g, "_")}`;
+		const baseId = `act_${label.toLowerCase().replace(/\s+/g, "_")}`;
+		const existing = getActs();
+		const id = existing.has(baseId) ? nextSuffix(baseId, (id$1) => existing.has(id$1)) : baseId;
 		this.node = createActNode(id, label, [], null, void 0, false);
 		registerActNode(this.node);
 	}
@@ -578,7 +722,9 @@ var ActBuilder = class {
 var FlowBuilder = class {
 	node;
 	constructor(name) {
-		const id = `flow_${name}`;
+		const baseId = `flow_${name}`;
+		const existing = getFlows();
+		const id = existing.has(baseId) ? nextSuffix(baseId, (id$1) => existing.has(id$1)) : baseId;
 		this.node = {
 			id,
 			name,
@@ -623,7 +769,9 @@ var FlowBuilder = class {
 var SurfaceBuilder = class {
 	node;
 	constructor(name) {
-		const id = `surface_${name}`;
+		const baseId = `surface_${name}`;
+		const existing = getSurfaces();
+		const id = existing.has(baseId) ? nextSuffix(baseId, (id$1) => existing.has(id$1)) : baseId;
 		this.node = {
 			id,
 			name,
@@ -662,13 +810,15 @@ function screen(name, fn) {
 		flow: (n) => new FlowBuilder(n),
 		surface: (n) => new SurfaceBuilder(n),
 		resource: (n, config) => {
-			const id = `resource_${n}`;
+			const baseId = `resource_${n}`;
+			const id = configs.some((c) => c.id === baseId) ? nextSuffix(baseId, (id$1) => configs.some((c) => c.id === id$1)) : baseId;
 			const ref = new ResourceRef(id, n, config.load, config.autoLoad ?? true);
 			configs.push({
 				id,
 				name: n,
 				autoLoad: config.autoLoad ?? true,
 				loader: config.load,
+				cache: config.cache,
 				ref
 			});
 			return ref;
@@ -691,6 +841,28 @@ function screen(name, fn) {
 
 //#endregion
 //#region src/graph.ts
+const NODE_KINDS = {
+	ask: "ask",
+	act: "action",
+	flow: "flow",
+	surface: "surface",
+	resource: "resource"
+};
+function slugify(text) {
+	return text.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+}
+function createSemanticIdFactory(kind) {
+	const prefix = NODE_KINDS[kind] ?? kind;
+	const used = /* @__PURE__ */ new Map();
+	let unnamed = 0;
+	return (source) => {
+		const slug = slugify(source);
+		const base = slug.length > 0 ? slug : String(++unnamed);
+		const count = used.get(base) ?? 0;
+		used.set(base, count + 1);
+		return count === 0 ? `${prefix}:${base}` : `${prefix}:${base}-${count + 1}`;
+	};
+}
 function computeDiagnostics(screenDef) {
 	const diagnostics = [];
 	const primaryActions = screenDef.acts.filter((a) => a.primary);
@@ -725,13 +897,66 @@ function computeDiagnostics(screenDef) {
 		message: "Action is defined but not included in any surface.",
 		nodeId: act.id
 	});
+	if (screenDef.flows.length > 0) {
+		const flowNodeIds = /* @__PURE__ */ new Set();
+		for (const flow of screenDef.flows) for (const step of flow.steps) flowNodeIds.add(step.node.id);
+		for (const flow of screenDef.flows) for (const step of flow.steps) if (!surfacedNodeIds.has(step.node.id)) diagnostics.push({
+			severity: "warning",
+			code: "flow-step-not-surfaced",
+			message: `"${step.node.label}" is a flow step but not included in any surface.`,
+			nodeId: step.node.id,
+			flow: { flowNodeId: flow.id }
+		});
+		for (const flow of screenDef.flows) if (flow.steps.length > 0) {
+			const hasSurfacedStep = flow.steps.some((step) => surfacedNodeIds.has(step.node.id));
+			if (!hasSurfacedStep) diagnostics.push({
+				severity: "warning",
+				code: "orphaned-flow",
+				message: `"${flow.name}" has no surfaced steps.`,
+				flow: { flowNodeId: flow.id }
+			});
+		}
+		for (const ask of screenDef.asks) if (surfacedNodeIds.has(ask.id) && !flowNodeIds.has(ask.id)) diagnostics.push({
+			severity: "info",
+			code: "surfaced-node-not-in-any-flow",
+			message: `"${ask.label}" is surfaced but not referenced in any flow.`,
+			nodeId: ask.id
+		});
+		for (const act of screenDef.acts) if (surfacedNodeIds.has(act.id) && !flowNodeIds.has(act.id)) diagnostics.push({
+			severity: "info",
+			code: "surfaced-node-not-in-any-flow",
+			message: `"${act.label}" is surfaced but not referenced in any flow.`,
+			nodeId: act.id
+		});
+	}
 	return diagnostics;
 }
 function inspectScreen(screenDef, runtimeResources) {
+	const diagnostics = computeDiagnostics(screenDef);
+	const askIds = createSemanticIdFactory("ask");
+	const actIds = createSemanticIdFactory("act");
+	const flowIds = createSemanticIdFactory("flow");
+	const surfaceIds = createSemanticIdFactory("surface");
+	const resourceIds = createSemanticIdFactory("resource");
+	const idToSemantic = /* @__PURE__ */ new Map();
+	for (const a of screenDef.asks) idToSemantic.set(a.id, askIds(a.label));
+	for (const a of screenDef.acts) idToSemantic.set(a.id, actIds(a.label));
+	const idToFlowSemantic = /* @__PURE__ */ new Map();
+	for (const f of screenDef.flows) idToFlowSemantic.set(f.id, flowIds(f.name));
+	const augmentedDiagnostics = diagnostics.map((d) => ({
+		...d,
+		semanticNodeId: d.nodeId ? idToSemantic.get(d.nodeId) : void 0,
+		flow: d.flow ? {
+			...d.flow,
+			flowSemanticNodeId: idToFlowSemantic.get(d.flow.flowNodeId)
+		} : void 0
+	}));
 	return {
 		name: screenDef.name,
+		semanticId: `screen:${slugify(screenDef.name)}`,
 		asks: screenDef.asks.map((a) => ({
 			id: a.id,
+			semanticId: idToSemantic.get(a.id),
 			label: a.label,
 			kind: a.kind,
 			required: a.required,
@@ -741,6 +966,7 @@ function inspectScreen(screenDef, runtimeResources) {
 		})),
 		acts: screenDef.acts.map((a) => ({
 			id: a.id,
+			semanticId: idToSemantic.get(a.id),
 			label: a.label,
 			primary: a.primary,
 			enabled: a.enabled.current,
@@ -751,23 +977,26 @@ function inspectScreen(screenDef, runtimeResources) {
 		})),
 		flows: screenDef.flows.map((f) => ({
 			id: f.id,
+			semanticId: idToFlowSemantic.get(f.id),
 			name: f.name,
 			stepCount: f.steps.length
 		})),
 		surfaces: screenDef.surfaces.map((s) => ({
 			id: s.id,
+			semanticId: surfaceIds(s.name),
 			name: s.name,
 			itemCount: s.items.length
 		})),
 		resources: (runtimeResources ?? []).map((r) => ({
 			id: r.id,
+			semanticId: resourceIds(r.name),
 			name: r.name,
 			status: r.status,
 			hasValue: r.value !== void 0,
 			stale: r.stale.current,
 			error: r.status === "failed" ? r.error instanceof Error ? r.error.message : String(r.error) : void 0
 		})),
-		diagnostics: computeDiagnostics(screenDef)
+		diagnostics: augmentedDiagnostics
 	};
 }
 
@@ -814,7 +1043,7 @@ var ScreenRuntime = class {
 		this._started = true;
 		const nodeMap = /* @__PURE__ */ new Map();
 		for (const config of this._screen.resourceConfigs) {
-			const node = createResourceNode(config.id, config.name, config.loader, false);
+			const node = createResourceNode(config.id, config.name, config.loader, false, config.cache);
 			this._resourceNodes.push(node);
 			nodeMap.set(config.id, node);
 		}
@@ -836,6 +1065,7 @@ var ScreenRuntime = class {
 		this._disposed = true;
 		for (const unsub of this._unsubscribers) unsub();
 		this._unsubscribers = [];
+		for (const node of this._resourceNodes) node.dispose();
 		for (const config of this._screen.resourceConfigs) if (config.ref && this._resourceNodeMap) {
 			const node = this._resourceNodeMap.get(config.id);
 			if (node) config.ref._disconnect(node);

package/dist/registry.d.ts

@@ -23,3 +23,4 @@ export declare function getActs(): Map<string, ActNode<any>>;
 export declare function getFlows(): Map<string, FlowNode>;
 export declare function getSurfaces(): Map<string, SurfaceNode>;
 export declare function getResources(): Map<string, AnyResourceNode>;
+export declare function nextSuffix(baseId: string, exists: (id: string) => boolean): string;

package/dist/resource.d.ts

@@ -1,6 +1,7 @@
 import { type Condition } from "./signal.js";
 import type { ActionExecutionContext, DefaultScreenServices } from "./act.js";
 export type ResourceStatus = "idle" | "pending" | "ready" | "failed";
+export type ResourceKey = string | number | boolean | null | undefined | ResourceKey[];
 export type ResourceLoadContext<TServices extends object = DefaultScreenServices> = ActionExecutionContext<TServices>;
 type ResourceLoader<TValue, TServices extends object> = (() => TValue | Promise<TValue>) | ((context: ResourceLoadContext<TServices>) => TValue | Promise<TValue>);
 export type ResourceNode<TValue, TServices extends object = DefaultScreenServices> = {
@@ -18,17 +19,25 @@ export type ResourceNode<TValue, TServices extends object = DefaultScreenService
     reload: (context?: ResourceLoadContext<TServices>) => Promise<void>;
     invalidate: () => void;
     subscribe: (fn: () => void) => () => void;
+    dispose: () => void;
 };
 export type AnyResourceNode = ResourceNode<unknown, any>;
+export type ResourceCacheOptions<TServices extends object = DefaultScreenServices> = {
+    key?: (context: ResourceLoadContext<TServices>) => ResourceKey;
+    staleTime?: number;
+    cacheTime?: number;
+    deduplicate?: boolean;
+};
 export type ResourceConfig<TValue = unknown, TServices extends object = DefaultScreenServices> = {
     id: string;
     name: string;
     autoLoad: boolean;
     loader: ResourceLoader<TValue, TServices>;
+    cache?: ResourceCacheOptions<TServices>;
     ref?: ResourceRef<TValue, TServices>;
 };
 export declare function createResourceConfig<TValue, TServices extends object = DefaultScreenServices>(id: string, name: string, loader: ResourceLoader<TValue, TServices>, autoLoad?: boolean): ResourceConfig<TValue, TServices>;
-export declare function createResourceNode<TValue, TServices extends object = DefaultScreenServices>(id: string, name: string, loader: ResourceLoader<TValue, TServices>, autoLoad?: boolean): ResourceNode<TValue, TServices>;
+export declare function createResourceNode<TValue, TServices extends object = DefaultScreenServices>(id: string, name: string, loader: ResourceLoader<TValue, TServices>, autoLoad?: boolean, cache?: ResourceCacheOptions<TServices>): ResourceNode<TValue, TServices>;
 export declare class ResourceRef<TValue, TServices extends object = DefaultScreenServices> {
     readonly id: string;
     readonly name: string;

package/dist/screen.d.ts

@@ -2,7 +2,7 @@ import type { AnyAskNode } from "./ask.js";
 import type { ActNode, DefaultScreenServices } from "./act.js";
 import type { FlowNode } from "./flow.js";
 import type { SurfaceNode } from "./surface.js";
-import type { ResourceConfig, ResourceLoadContext } from "./resource.js";
+import type { ResourceCacheOptions, ResourceConfig, ResourceLoadContext } from "./resource.js";
 import { ResourceRef } from "./resource.js";
 import { type TextState, type BooleanState, type ChoiceState } from "./state.js";
 import { AskBuilder } from "./ask.js";
@@ -31,6 +31,7 @@ export type ScreenBuilder<TServices extends object = DefaultScreenServices> = {
     resource: <T>(name: string, config: {
         load: (() => Promise<T>) | ((context: ResourceLoadContext<TServices>) => Promise<T>);
         autoLoad?: boolean;
+        cache?: ResourceCacheOptions<TServices>;
     }) => ResourceRef<T, TServices>;
 };
 export type ScreenDefinition<TServices extends object = DefaultScreenServices> = {

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.0-alpha.0",
+  "version": "0.1.0-alpha.10",
   "description": "Platformless semantic graph and runtime for Intent applications",
   "license": "MIT",
   "repository": {