@statelyai/sdk 0.39.1 → 0.41.0

package/dist/machineGraph-DYtFKHlq-ChbeTHlv.mjs

@@ -0,0 +1,1023 @@
+import { Et as array, Nn as record, Rn as string, Tn as object, Xn as union, Zn as unknown, dn as literal, wn as number } from "./schemas-DsQ8UYlM.mjs";
+import { a as XSTATE_V5_PROFILE, d as isCodeExpression, f as isXStateV6Profile, h as serializeJS, i as SERIALIZED_SOURCE_ID, m as raw, n as FN_PROJECTION_META, o as XSTATE_V6_BRANCH_DESCRIPTION_META, p as normalizeMachineProfile, t as __exportAll } from "./rolldown-runtime-95iHPtFO-Bo6l7CbO.mjs";
+
+//#region ../graph-tools/dist/machineGraph-DYtFKHlq.mjs
+function normalizeProfileRef(profile) {
+	return profile === "xstate-v5" || profile === "xstate-v6-alpha" ? normalizeMachineProfile(profile) : profile;
+}
+const AFTER_EVENT_PREFIX = "xstate.after.";
+/** Recovers an authored delay key from an internal after-event type. */
+function getDelayKeyFromEventType(eventType, sourceId) {
+	if (!eventType.startsWith(AFTER_EVENT_PREFIX)) return null;
+	const encoded = eventType.slice(13);
+	const sourceSuffix = sourceId ? `.${sourceId}` : null;
+	if (sourceSuffix && encoded.endsWith(sourceSuffix)) return encoded.slice(0, -sourceSuffix.length);
+	return encoded.split(".")[0] ?? encoded;
+}
+function isAutoGeneratedId(id) {
+	return !!id && id.startsWith("$auto-");
+}
+function getAuthoredNodeId(node) {
+	const authored = node.data.nodeId ?? void 0;
+	return authored && !isAutoGeneratedId(authored) ? authored : void 0;
+}
+function getRootEmittedId(graph, node) {
+	if (graph.id === "root" && node.data.key && node.data.key !== "root") return getAuthoredNodeId(node) ?? node.data.key;
+	return getAuthoredNodeId(node) ?? (isAutoGeneratedId(graph.id) ? void 0 : graph.id);
+}
+function getDefaultPathId(graph, node) {
+	if (!node.parentId) return getRootEmittedId(graph, node) ?? "(machine)";
+	const parentNode = graph.nodes.find((candidate) => candidate.id === node.parentId);
+	if (!parentNode) return node.data.key;
+	return `${getDefaultPathId(graph, parentNode)}.${node.data.key}`;
+}
+function getEmittedNodeId(graph, node) {
+	const authored = getAuthoredNodeId(node);
+	if (!node.parentId) return getRootEmittedId(graph, node);
+	if (!authored) return void 0;
+	return authored;
+}
+function getResolvedNodeId(graph, node) {
+	return getEmittedNodeId(graph, node) ?? getDefaultPathId(graph, node);
+}
+/**
+* Strips `export default` wrapper from an expression string.
+* E.g. `"export default assign({ ... })"` → `"assign({ ... })"`
+*/
+function stripExportDefault(code) {
+	const trimmed = code.trim();
+	if (trimmed.startsWith("export default ")) return trimmed.slice(15).replace(/;$/, "");
+	return trimmed;
+}
+/**
+* Graph-native transition references. Transitions point at invoke/action/state
+* blocks by graph id (`@statelyai.*`); the literal `xstate.*` event is produced
+* here at codegen time. Literal `xstate.*` strings (pre-resolved, e.g. baked by
+* an import) are passed through unchanged.
+*/
+const STATELY_PREFIX = "@statelyai";
+/** Legacy prefix accepted on read for graphs persisted before the rename. */
+const LEGACY_STATELY_PREFIX = "@stately";
+const STATELY_REF_PREFIX = {
+	invokeDone: "@statelyai.invoke.done",
+	invokeError: "@statelyai.invoke.error",
+	invokeSnapshot: "@statelyai.invoke.snapshot",
+	invokeTimeout: "@statelyai.invoke.timeout",
+	actionDone: "@statelyai.action.done",
+	actionError: "@statelyai.action.error",
+	stateDone: "@statelyai.state.done",
+	stateError: "@statelyai.state.error",
+	stateTimeout: "@statelyai.state.timeout"
+};
+function parseStatelyRef(eventType) {
+	if (eventType.startsWith(`${LEGACY_STATELY_PREFIX}.`)) eventType = `${STATELY_PREFIX}${eventType.slice(8)}`;
+	if (!eventType.startsWith(`${STATELY_PREFIX}.`)) return null;
+	for (const kind of Object.keys(STATELY_REF_PREFIX)) {
+		const prefix = STATELY_REF_PREFIX[kind];
+		if (eventType === prefix) return {
+			kind,
+			blockId: ""
+		};
+		if (eventType.startsWith(`${prefix}.`)) return {
+			kind,
+			blockId: eventType.slice(prefix.length + 1)
+		};
+	}
+	return null;
+}
+/** Find an invoke block by its graph id, or by its emitted id (legacy literals). */
+function findInvokeByActorId(node, actorId) {
+	const invokes = node.data.invokes ?? [];
+	return invokes.find((inv) => inv.id === actorId) ?? invokes.find((inv) => (inv.invocationId ?? inv.id) === actorId);
+}
+/** Resolve a spawn action block id to its spawned actor id (`params.id`). */
+function resolveSpawnActorId(node, actionId) {
+	const spawnId = [...node.data.entry ?? [], ...node.data.exit ?? []].find((action) => action.id === actionId)?.params?.["id"];
+	return typeof spawnId === "string" && spawnId ? spawnId : actionId;
+}
+/**
+* Resolve an edge's target into the string XState expects on the source state.
+* Prefer a relative key path (resolved against the source's parent, or the root
+* itself for root transitions) so output reads like a hand-written machine —
+* e.g. a sibling's child becomes `Unlocked.Manual`. Fall back to an absolute
+* `#id` reference only when the target lives outside the source's subtree.
+*/
+function resolveTransitionTarget(graph, sourceNode, targetNode) {
+	const isRootSource = sourceNode.parentId == null;
+	const baseId = sourceNode.parentId ?? sourceNode.id;
+	const keys = [];
+	let current = targetNode;
+	while (current) {
+		keys.unshift(current.data.key.replace(/\\/g, "\\\\").replace(/\./g, "\\."));
+		if (current.parentId === baseId) {
+			if (isRootSource) return `.${keys.join(".")}`;
+			return keys.join(".");
+		}
+		const parentId = current.parentId;
+		current = graph.nodes.find((n) => n.id === parentId);
+	}
+	return `#${getAbsoluteTargetId(graph, targetNode)}`;
+}
+function getAbsoluteTargetId(graph, targetNode) {
+	const resolved = getResolvedNodeId(graph, targetNode);
+	if (!resolved.startsWith("root.")) return resolved;
+	const rootNode = graph.nodes.find((node) => node.parentId === null);
+	const rootKey = rootNode?.data.nodeId && !isAutoGeneratedId(rootNode.data.nodeId) ? rootNode.data.nodeId : rootNode?.data.key;
+	return rootKey && rootKey !== "root" ? `${rootKey}.${resolved.slice(5)}` : resolved;
+}
+/** Unwrap single-element arrays to a single value (XState single-or-array convention) */
+function singleOrArray(arr) {
+	return arr.length === 1 ? arr[0] : arr;
+}
+/** Unwrap each value in a record of arrays */
+function singleOrArrayRecord(record) {
+	const result = {};
+	for (const [key, arr] of Object.entries(record)) result[key] = singleOrArray(arr);
+	return result;
+}
+/**
+* Remove empty arrays/objects/strings, unwrap single-element arrays.
+* Matches studio's simplifyAttributes behavior.
+*/
+/**
+* Keys whose empty object value is authored, not incidental: `context: {}`
+* declares that the machine has context, so dropping it loses information.
+*/
+const KEEP_WHEN_EMPTY = new Set(["context"]);
+const KEEP_SINGLETON_ARRAY = new Set(["internalEvents", "tags"]);
+function simplifyAttributes(obj) {
+	for (const key of Object.keys(obj)) {
+		const value = obj[key];
+		if (value === void 0 || value === null) delete obj[key];
+		else if (KEEP_WHEN_EMPTY.has(key)) continue;
+		else if (Array.isArray(value)) {
+			if (value.length === 0) delete obj[key];
+			else if (value.length === 1 && !KEEP_SINGLETON_ARRAY.has(key)) obj[key] = value[0];
+		} else if (typeof value === "object" && Object.keys(value).length === 0) delete obj[key];
+		else if (typeof value === "string" && value === "") delete obj[key];
+	}
+	return obj;
+}
+/**
+* Recursively apply simplifyAttributes to a config tree.
+* Cleans up the config and all nested state nodes, transitions, and invokes.
+*/
+function deepSimplify(config) {
+	for (const mapKey of ["on", "after"]) {
+		const map = config[mapKey];
+		if (map && typeof map === "object" && !Array.isArray(map)) {
+			for (const [, val] of Object.entries(map)) if (val && typeof val === "object" && !Array.isArray(val)) simplifyAttributes(val);
+			else if (Array.isArray(val)) {
+				for (const item of val) if (item && typeof item === "object") simplifyAttributes(item);
+			}
+		}
+	}
+	for (const key of [
+		"always",
+		"onDone",
+		"onError",
+		"onTimeout"
+	]) {
+		const val = config[key];
+		if (val && typeof val === "object" && !Array.isArray(val)) simplifyAttributes(val);
+		else if (Array.isArray(val)) {
+			for (const item of val) if (item && typeof item === "object") simplifyAttributes(item);
+		}
+	}
+	const invoke = config.invoke;
+	if (invoke && typeof invoke === "object" && !Array.isArray(invoke)) simplifyAttributes(invoke);
+	else if (Array.isArray(invoke)) {
+		for (const item of invoke) if (item && typeof item === "object") simplifyAttributes(item);
+	}
+	simplifyAttributes(config);
+	if (config.states && typeof config.states === "object") for (const stateConfig of Object.values(config.states)) deepSimplify(stateConfig);
+	return config;
+}
+function buildMeta(meta, color, showStatelyMeta = true) {
+	if (isCodeExpression(meta)) return meta;
+	const result = {};
+	if (meta) {
+		for (const [k, v] of Object.entries(meta)) if (v !== void 0 && v !== null && (showStatelyMeta || k === FN_PROJECTION_META || !k.startsWith("@statelyai"))) result[k] = v;
+	}
+	if (color !== void 0 && showStatelyMeta) result["@statelyai.color"] = color;
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+/** Format event param — supports { type: string } (new) and plain string (legacy) */
+function formatEventParam(event) {
+	if (isCodeExpression(event)) return serializeJS(event);
+	if (event && typeof event === "object" && "type" in event) return formatInlineObject(event);
+	if (typeof event === "string") return `{ type: '${event}' }`;
+	return "undefined";
+}
+function formatStringParam(value) {
+	if (typeof value === "string") return `'${value}'`;
+	return isCodeExpression(value) ? serializeJS(value) : "undefined";
+}
+function formatInlineObject(value) {
+	return serializeJS(raw(`{ ${Object.entries(value).filter(([, item]) => item !== void 0).map(([key, item]) => `${formatObjectKey(key)}: ${serializeJS(item)}`).join(", ")} }`, value));
+}
+function formatObjectKey(key) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+const codeExpressionParamSchema = object({
+	"@type": literal("code"),
+	expr: string()
+}).passthrough();
+const eventParamSchema = union([
+	string(),
+	object({ type: string() }).catchall(unknown()),
+	codeExpressionParamSchema
+]);
+const stringOrCodeParamSchema = union([string(), codeExpressionParamSchema]);
+const delayParamSchema = union([
+	number(),
+	string(),
+	codeExpressionParamSchema
+]);
+const builtInActionParamSchemas = {
+	"xstate.enqueue": object({
+		code: string().optional(),
+		lang: string().optional()
+	}),
+	"xstate.raise": object({
+		event: eventParamSchema.optional(),
+		id: stringOrCodeParamSchema.optional(),
+		delay: delayParamSchema.optional()
+	}),
+	"xstate.sendTo": object({
+		to: stringOrCodeParamSchema.optional(),
+		event: eventParamSchema.optional(),
+		id: stringOrCodeParamSchema.optional(),
+		delay: delayParamSchema.optional()
+	}),
+	"xstate.cancel": object({ sendId: stringOrCodeParamSchema.optional() }),
+	"xstate.emit": object({ event: eventParamSchema.optional() }),
+	"xstate.spawnChild": object({
+		src: stringOrCodeParamSchema.optional(),
+		id: stringOrCodeParamSchema.optional(),
+		systemId: stringOrCodeParamSchema.optional(),
+		input: unknown().optional()
+	}),
+	"xstate.stopChild": object({ actorRef: stringOrCodeParamSchema.optional() }),
+	"xstate.log": object({ label: unknown().optional() }),
+	"xstate.assign": object({ assignment: record(string(), unknown()).optional() }).catchall(unknown()),
+	"xstate.choose": object({ branches: array(object({
+		guard: unknown().optional(),
+		actions: array(unknown()).optional()
+	})).optional() })
+};
+const XSTATE_BUILT_IN_ACTIONS = {
+	"xstate.enqueue": {
+		package: "xstate",
+		version: "^6",
+		import: "enqueue",
+		importKind: "named",
+		paramsSchema: builtInActionParamSchemas["xstate.enqueue"],
+		emit(params) {
+			return typeof params?.code === "string" ? stripExportDefault(params.code) : "";
+		}
+	},
+	"xstate.raise": {
+		package: "xstate",
+		version: "^5",
+		import: "raise",
+		importKind: "named",
+		paramsSchema: builtInActionParamSchemas["xstate.raise"],
+		emit(params) {
+			const eventStr = formatEventParam(params?.event);
+			const opts = [];
+			if (params?.id) opts.push(`id: ${formatStringParam(params.id)}`);
+			if (params?.delay != null) opts.push(`delay: ${serializeJS(params.delay)}`);
+			return `raise(${eventStr}${opts.length > 0 ? `, { ${opts.join(", ")} }` : ""})`;
+		}
+	},
+	"xstate.sendTo": {
+		package: "xstate",
+		version: "^5",
+		import: "sendTo",
+		importKind: "named",
+		paramsSchema: builtInActionParamSchemas["xstate.sendTo"],
+		emit(params) {
+			const to = formatStringParam(params?.to);
+			const eventStr = formatEventParam(params?.event);
+			const opts = [];
+			if (params?.id) opts.push(`id: ${formatStringParam(params.id)}`);
+			if (params?.delay != null) opts.push(`delay: ${serializeJS(params.delay)}`);
+			return `sendTo(${to}, ${eventStr}${opts.length > 0 ? `, { ${opts.join(", ")} }` : ""})`;
+		}
+	},
+	"xstate.cancel": {
+		package: "xstate",
+		version: "^5",
+		import: "cancel",
+		importKind: "named",
+		paramsSchema: builtInActionParamSchemas["xstate.cancel"],
+		emit(params) {
+			return `cancel(${formatStringParam(params?.sendId)})`;
+		}
+	},
+	"xstate.emit": {
+		package: "xstate",
+		version: "^5",
+		import: "emit",
+		importKind: "named",
+		paramsSchema: builtInActionParamSchemas["xstate.emit"],
+		emit(params) {
+			return `emit(${formatEventParam(params?.event)})`;
+		}
+	},
+	"xstate.spawnChild": {
+		package: "xstate",
+		version: "^5",
+		import: "spawnChild",
+		importKind: "named",
+		paramsSchema: builtInActionParamSchemas["xstate.spawnChild"],
+		emit(params) {
+			const src = formatStringParam(params?.src);
+			const opts = [];
+			if (params?.id) opts.push(`id: ${formatStringParam(params.id)}`);
+			if (params?.systemId) opts.push(`systemId: ${formatStringParam(params.systemId)}`);
+			if (params?.input !== void 0) opts.push(`input: ${serializeJS(params.input)}`);
+			return `spawnChild(${src}${opts.length > 0 ? `, { ${opts.join(", ")} }` : ""})`;
+		}
+	},
+	"xstate.stopChild": {
+		package: "xstate",
+		version: "^5",
+		import: "stopChild",
+		importKind: "named",
+		paramsSchema: builtInActionParamSchemas["xstate.stopChild"],
+		emit(params) {
+			return `stopChild(${formatStringParam(params?.actorRef)})`;
+		}
+	},
+	"xstate.log": {
+		package: "xstate",
+		version: "^5",
+		import: "log",
+		importKind: "named",
+		paramsSchema: builtInActionParamSchemas["xstate.log"],
+		emit(params) {
+			return `log(${(params?.label !== void 0 ? serializeJS(params.label) : void 0) ?? ""})`;
+		}
+	},
+	"xstate.choose": {
+		package: "xstate",
+		version: "^5",
+		import: "enqueueActions",
+		importKind: "named",
+		paramsSchema: builtInActionParamSchemas["xstate.choose"],
+		emit(params) {
+			return emitChooseBranches(params?.branches ?? []);
+		}
+	},
+	"xstate.assign": {
+		package: "xstate",
+		version: "^5",
+		import: "assign",
+		importKind: "named",
+		paramsSchema: builtInActionParamSchemas["xstate.assign"],
+		emit(params) {
+			if (isCodeExpression(params?.assignment)) return `assign(${serializeJS(params.assignment)})`;
+			const assignments = params?.assignment && typeof params.assignment === "object" && !Array.isArray(params.assignment) ? params.assignment : params;
+			const entries = Object.entries(assignments ?? {}).filter(([k, v]) => k && v !== void 0);
+			if (entries.length === 0) return "assign({})";
+			return `assign({ ${entries.map(([k, v]) => `${JSON.stringify(k)}: ${formatAssignValue(v)}`).join(", ")} })`;
+		}
+	}
+};
+function isBuiltInActionType(type) {
+	return type in XSTATE_BUILT_IN_ACTIONS;
+}
+/** Lower `xstate.choose` branches to an `enqueueActions` if/else-if chain. */
+function emitChooseBranches(branches) {
+	const lines = [];
+	const indent = (depth) => "  ".repeat(depth);
+	const serializeEnqueued = (action, depth) => {
+		if (action && typeof action === "object" && !Array.isArray(action) && Object.keys(action).length === 1 && typeof action.type === "string") return serializeJS(action.type);
+		return serializeJS(action, depth * 2);
+	};
+	const body = (actions, depth) => (actions ?? []).map((action) => `${indent(depth)}enqueue(${serializeEnqueued(action, depth)});`);
+	let closed = false;
+	let opened = false;
+	for (const branch of branches) {
+		if (closed) break;
+		if (branch.guard === void 0) {
+			if (opened) {
+				lines.push(`  } else {`);
+				lines.push(...body(branch.actions, 2));
+				lines.push("  }");
+			} else lines.push(...body(branch.actions, 1));
+			closed = true;
+			continue;
+		}
+		lines.push(`  ${opened ? "} else if" : "if"} (check(${serializeJS(branch.guard)})) {`);
+		lines.push(...body(branch.actions, 2));
+		opened = true;
+	}
+	if (opened && !closed) lines.push("  }");
+	return `enqueueActions(({ check, enqueue }) => {\n${lines.join("\n")}\n})`;
+}
+function emitBuiltInAction(type, params) {
+	return XSTATE_BUILT_IN_ACTIONS[type].emit(params);
+}
+function actionCodeExpression(expr, source) {
+	return {
+		"@type": "code",
+		lang: "ts",
+		expr,
+		imports: [{
+			package: source.package,
+			version: source.version,
+			import: source.import,
+			importKind: source.importKind
+		}]
+	};
+}
+function inlineCodeExpression(expr, sourceValue) {
+	const result = {
+		"@type": "code",
+		lang: "ts",
+		expr: stripExportDefault(expr)
+	};
+	const sourceId = sourceValue?.[SERIALIZED_SOURCE_ID];
+	if (sourceId !== void 0) Object.defineProperty(result, SERIALIZED_SOURCE_ID, {
+		value: sourceId,
+		enumerable: true
+	});
+	return result;
+}
+/**
+* Serialize an edge guard for a machine config. Codegen emits inline guards as
+* a code-expression directive so the source round-trips. The simulation passes
+* `asTypeRef` to get a plain `{ type }` reference instead (it stubs guards by
+* type and can't evaluate the source) — see MachineConfigOptions.
+*/
+function serializeGuard(guard, asTypeRef) {
+	if (asTypeRef) return guard.params ? {
+		type: guard.type,
+		params: guard.params
+	} : { type: guard.type };
+	return guard.code ? inlineCodeExpression(guard.code, guard) : guard;
+}
+/**
+* Converts a built-in xstate ActionItem to a code expression directive,
+* or returns a plain { type, params } object for user-defined actions.
+*/
+function serializeActionItem(action, keepChooseStructured = false) {
+	const { type, params } = action;
+	if (keepChooseStructured && type === "xstate.choose") return {
+		type,
+		params
+	};
+	if (type === "xstate.enqueue" && typeof params?.code === "string") return inlineCodeExpression(params.code, action);
+	const exprCode = type === "xstate.expr" && typeof params?.code === "string" ? params.code : void 0;
+	if (isBuiltInActionType(type)) {
+		const builtInAction = XSTATE_BUILT_IN_ACTIONS[type];
+		return actionCodeExpression(emitBuiltInAction(type, params), builtInAction);
+	}
+	if (exprCode) return inlineCodeExpression(exprCode, action);
+	if (!params || Object.keys(params).length === 0) return { type };
+	return {
+		type,
+		params
+	};
+}
+function formatAssignValue(value) {
+	if (typeof value !== "string") return serializeJS(value);
+	const templateExpression = value.match(/^\{\{([\s\S]*)\}\}$/);
+	if (templateExpression) return templateExpression[1].trim();
+	return JSON.stringify(value);
+}
+/** Normalize tag to string — handles both `string` and `{ name: string }` */
+function tagToString(tag) {
+	return typeof tag === "string" ? tag : tag.name;
+}
+function graphToMachineConfig(graph, options = {}) {
+	const v6 = isXStateV6Profile(graph.data.profile);
+	const { showDescriptions = true, showMeta = true, showStatelyMeta = true, inlineGuardsAsTypeRef = false, keepChooseStructured = false, timerActionsAsTypeRef = false } = options;
+	const serializeAction = (action) => timerActionsAsTypeRef && ["xstate.raise", "xstate.cancel"].includes(action.type) ? {
+		type: action.type,
+		params: action.params
+	} : serializeActionItem(action, keepChooseStructured);
+	const config = {};
+	function getNodeConfig(node) {
+		const nodeConfig = node.parentId ? {} : config;
+		const resolvedNodeId = getEmittedNodeId(graph, node);
+		const initialNode = node.data.initialId ? graph.nodes.find((n) => n.id === node.data.initialId) : null;
+		const nodeType = [
+			"final",
+			"history",
+			"parallel",
+			"choice"
+		].includes(node.data.type) ? node.data.type : void 0;
+		const tags = node.data.tags;
+		const stateMeta = showMeta ? buildMeta({
+			...node.data.meta,
+			...node.data.assets?.length ? { "@statelyai.assets": node.data.assets.map(({ type, url, size, width, height, name, metadata }) => ({
+				type,
+				url,
+				...size ? { size } : {},
+				...name !== void 0 ? { name } : {},
+				...metadata !== void 0 ? { metadata } : {},
+				...type === "iframe" ? {
+					...width !== void 0 ? { width } : {},
+					...height !== void 0 ? { height } : {}
+				} : {}
+			})) } : {},
+			...node.data.appearance ? { "@statelyai.appearance": node.data.appearance } : {}
+		}, node.data.color, showStatelyMeta) : void 0;
+		Object.assign(nodeConfig, {
+			id: resolvedNodeId,
+			type: nodeType === "normal" ? void 0 : nodeType ?? void 0,
+			initial: initialNode ? nodeType === "history" ? void 0 : node.data.initialInput !== void 0 ? {
+				target: initialNode.data.key,
+				input: node.data.initialInput
+			} : initialNode.data.key : void 0,
+			target: nodeType === "history" && initialNode ? resolveTransitionTarget(graph, node, initialNode) : void 0,
+			...node.data.timeout !== void 0 ? { timeout: node.data.timeout } : void 0,
+			...node.data.route !== void 0 ? { route: node.data.route } : void 0,
+			...node.data.entry?.length ? { entry: node.data.entry.map(serializeAction) } : void 0,
+			...node.data.exit?.length ? { exit: node.data.exit.map(serializeAction) } : void 0,
+			...node.data.invokes?.length ? { invoke: node.data.invokes.map((inv) => ({
+				src: inv.srcExpression ?? inv.src,
+				id: inv.invocationId ?? inv.id,
+				...inv.registryKey ? { registryKey: inv.registryKey } : void 0,
+				...inv.timeout !== void 0 ? { timeout: inv.timeout } : void 0,
+				...inv.input !== void 0 ? { input: inv.input } : void 0,
+				...inv.output !== void 0 ? { output: inv.output } : void 0
+			})) } : void 0,
+			...node.data.output !== void 0 ? { output: node.data.output } : void 0,
+			...node.data.schemas ? { schemas: node.data.schemas } : void 0,
+			...tags?.length ? { tags: tags.map(tagToString) } : void 0,
+			...showDescriptions && node.data.description ? { description: node.data.description } : void 0,
+			...stateMeta ? { meta: stateMeta } : void 0,
+			...node.data.history ? { history: node.data.history } : void 0
+		});
+		const childNodes = graph.nodes.filter((n) => n.parentId === node.id && !n.data.temp);
+		const edges = graph.edges.filter((edge) => edge.sourceId === node.id && !edge.data.temp);
+		if (edges.length > 0) {
+			const on = {};
+			const transitionOrder = /* @__PURE__ */ new Map();
+			const scxmlTransitions = [];
+			const after = {};
+			const alwaysArr = [];
+			const choiceArr = [];
+			const onDone = {};
+			const onError = [];
+			const onTimeout = [];
+			const invokeMap = {};
+			for (const edge of edges) {
+				const targetNode = graph.nodes.find((n) => n.id === edge.targetId);
+				const resolvedTarget = targetNode ? resolveTransitionTarget(graph, node, targetNode) : "";
+				const resolvedTargets = [resolvedTarget, ...(edge.data.additionalTargetIds ?? []).flatMap((targetId) => {
+					const additionalTarget = graph.nodes.find((n) => n.id === targetId);
+					return additionalTarget ? [resolveTransitionTarget(graph, node, additionalTarget)] : [];
+				})].filter(Boolean);
+				const type = edge.data.eventType ?? "";
+				const transitionMeta = showMeta ? buildMeta({
+					...edge.data.meta,
+					...edge.data.assets?.length ? { "@statelyai.assets": edge.data.assets.map(({ type, url, size, width, height, name, metadata }) => ({
+						type,
+						url,
+						...size ? { size } : {},
+						...name !== void 0 ? { name } : {},
+						...metadata !== void 0 ? { metadata } : {},
+						...type === "iframe" ? {
+							...width !== void 0 ? { width } : {},
+							...height !== void 0 ? { height } : {}
+						} : {}
+					})) } : {},
+					...edge.data.appearance ? { "@statelyai.appearance": edge.data.appearance } : {}
+				}, edge.data.color, showStatelyMeta) : edge.data.meta?.[FN_PROJECTION_META] ? { [FN_PROJECTION_META]: edge.data.meta[FN_PROJECTION_META] } : void 0;
+				const transitionObject = {
+					...edge.data.matches ? { matches: edge.data.matches } : void 0,
+					target: edge.data.transitionType === "targetless" ? void 0 : resolvedTargets.length > 1 ? resolvedTargets : `${resolvedTarget}`,
+					...edge.data.transitionType === "reenter" ? { reenter: true } : void 0,
+					guard: edge.data.guard ? serializeGuard(edge.data.guard, inlineGuardsAsTypeRef) : void 0,
+					...edge.data.context !== void 0 ? { context: edge.data.context } : void 0,
+					...edge.data.input !== void 0 ? { input: edge.data.input } : void 0,
+					actions: edge.data.actions?.length ? edge.data.actions.map(serializeAction) : void 0,
+					description: showDescriptions ? edge.data.description ?? void 0 : void 0,
+					...transitionMeta ? { meta: transitionMeta } : void 0
+				};
+				transitionOrder.set(transitionObject, transitionOrder.size);
+				const pushOn = (key) => {
+					if (!on[key]) on[key] = [];
+					on[key].push(transitionObject);
+				};
+				const nestInvoke = (blockId, slot) => {
+					invokeMap[blockId] = {
+						...invokeMap[blockId],
+						[slot]: (invokeMap[blockId]?.[slot] ?? []).concat(transitionObject)
+					};
+				};
+				const ref = parseStatelyRef(type);
+				if (ref) if (ref.kind === "invokeDone") nestInvoke(ref.blockId, "onDone");
+				else if (ref.kind === "invokeError") nestInvoke(ref.blockId, "onError");
+				else if (ref.kind === "invokeSnapshot") nestInvoke(ref.blockId, "onSnapshot");
+				else if (ref.kind === "invokeTimeout") nestInvoke(ref.blockId, "onTimeout");
+				else if (ref.kind === "stateDone") {
+					if (!onDone[type]) onDone[type] = [];
+					onDone[type].push(transitionObject);
+				} else if (ref.kind === "stateError") onError.push(transitionObject);
+				else if (ref.kind === "stateTimeout") onTimeout.push(transitionObject);
+				else {
+					const verb = ref.kind === "actionDone" ? "done" : "error";
+					const actorId = resolveSpawnActorId(node, ref.blockId);
+					if (v6) {
+						const eventType = `xstate.${verb}.actor`;
+						if (!on[eventType]) on[eventType] = [];
+						on[eventType].push({
+							...transitionObject,
+							matches: {
+								...transitionObject.matches,
+								actorId
+							}
+						});
+					} else pushOn(`xstate.${verb}.actor.${actorId}`);
+				}
+				else if (edge.data.route) continue;
+				else if (type === "" && node.data.type === "choice") choiceArr.push(transitionObject);
+				else if (type === "") alwaysArr.push(transitionObject);
+				else if (type.startsWith("xstate.after.")) {
+					const delayKey = getDelayKeyFromEventType(type, edge.sourceId);
+					if (!after[delayKey]) after[delayKey] = [];
+					after[delayKey].push(transitionObject);
+				} else if (edge.data.meta?.["@statelyai.scxml.eventDescriptor"]) scxmlTransitions.push({
+					descriptor: type,
+					transition: transitionObject
+				});
+				else if (type === "*") pushOn("*");
+				else if (type.startsWith("xstate.done.state")) {
+					if (!onDone[type]) onDone[type] = [];
+					onDone[type].push(transitionObject);
+				} else if (type.startsWith("xstate.done.actor.") || type.startsWith("xstate.error.actor.") || type.startsWith("xstate.snapshot.actor.") || type.startsWith("xstate.snapshot.")) {
+					const verb = type.startsWith("xstate.done.actor.") ? "onDone" : type.startsWith("xstate.error.actor.") ? "onError" : "onSnapshot";
+					const invoke = findInvokeByActorId(node, type.startsWith("xstate.snapshot.") ? type.slice(16).replace(/^actor\./, "") : type.slice(type.lastIndexOf(".actor.") + 7));
+					if (invoke) nestInvoke(invoke.id, verb);
+					else pushOn(type);
+				} else pushOn(type);
+			}
+			const descriptorBase = (descriptor) => descriptor.replace(/\.\*$/, "");
+			const scxmlKeys = new Set([...Object.keys(on), ...scxmlTransitions.flatMap(({ descriptor }) => descriptor === "*" ? ["*"] : descriptorBase(descriptor) ? [descriptorBase(descriptor), `${descriptorBase(descriptor)}.*`] : [])]);
+			for (const key of scxmlKeys) {
+				const base = descriptorBase(key);
+				const matching = scxmlTransitions.filter(({ descriptor }) => {
+					const prefix = descriptorBase(descriptor);
+					return descriptor === "*" || base === prefix || base.startsWith(`${prefix}.`);
+				}).map(({ transition }) => transition);
+				on[key] = [...new Set([...on[key] ?? [], ...matching])].sort((a, b) => (transitionOrder.get(a) ?? 0) - (transitionOrder.get(b) ?? 0));
+			}
+			if (Object.keys(on).length > 0) nodeConfig.on = singleOrArrayRecord(on);
+			if (Object.keys(after).length > 0) nodeConfig.after = singleOrArrayRecord(after);
+			if (alwaysArr.length > 0) nodeConfig.always = singleOrArray(alwaysArr);
+			if (choiceArr.length > 0) nodeConfig.choice = singleOrArray(choiceArr);
+			if (Object.keys(onDone).length > 0) nodeConfig.onDone = singleOrArray(Object.values(onDone).flat());
+			if (onError.length > 0) nodeConfig.onError = singleOrArray(onError);
+			if (onTimeout.length > 0) nodeConfig.onTimeout = singleOrArray(onTimeout);
+			if (Object.keys(invokeMap).length > 0 && Array.isArray(nodeConfig.invoke)) nodeConfig.invoke = nodeConfig.invoke.map((inv, index) => {
+				const mapped = invokeMap[node.data.invokes?.[index]?.id ?? inv.id];
+				if (!mapped) return inv;
+				return {
+					...inv,
+					...mapped.onDone ? { onDone: singleOrArray(mapped.onDone) } : void 0,
+					...mapped.onError ? { onError: singleOrArray(mapped.onError) } : void 0,
+					...mapped.onSnapshot ? { onSnapshot: singleOrArray(mapped.onSnapshot) } : void 0,
+					...mapped.onTimeout ? { onTimeout: singleOrArray(mapped.onTimeout) } : void 0
+				};
+			});
+		}
+		if (Array.isArray(nodeConfig.invoke)) nodeConfig.invoke = nodeConfig.invoke.map((inv) => {
+			if (inv.id && !isAutoGeneratedId(inv.id)) return inv;
+			const { id: _id, ...rest } = inv;
+			return rest;
+		});
+		if (childNodes.length > 0) {
+			nodeConfig.states = {};
+			for (const childState of childNodes) nodeConfig.states[childState.data.key] = getNodeConfig(childState);
+		}
+		return nodeConfig;
+	}
+	const rootNode = graph.nodes.find((node) => node.parentId === null || node.parentId == null);
+	if (!rootNode) throw new Error("No root node found");
+	getNodeConfig(rootNode);
+	if (graph.data.context !== void 0 && graph.data.context !== null) config.context = graph.data.context;
+	if (graph.data.version) config.version = graph.data.version;
+	if (graph.data.options?.maxIterations !== void 0) config.options = { maxIterations: graph.data.options.maxIterations };
+	if (graph.data.internalEvents?.length) config.internalEvents = graph.data.internalEvents;
+	return deepSimplify(config);
+}
+var machineGraph_exports = /* @__PURE__ */ __exportAll({
+	applyDefaultInitialIds: () => applyDefaultInitialIds,
+	graphToNormalizedMachine: () => graphToNormalizedMachine,
+	machineConfigToGraph: () => machineConfigToGraph
+});
+/**
+* A compound state node with no usable `initial` cannot be simulated (XState
+* throws "No initial state specified for compound state node"). This walks a
+* finished graph and defaults every such node's `initialId` to its first child,
+* which also repairs `initial` references that resolved to no node at all.
+*/
+function applyDefaultInitialIds(nodes) {
+	const childrenByParentId = /* @__PURE__ */ new Map();
+	const nodeIds = new Set(nodes.map((node) => node.id));
+	for (const node of nodes) {
+		if (node.parentId === null || node.parentId === void 0) continue;
+		if (node.data.type === "annotation") continue;
+		const siblings = childrenByParentId.get(node.parentId);
+		if (siblings) siblings.push(node);
+		else childrenByParentId.set(node.parentId, [node]);
+	}
+	for (const node of nodes) {
+		const type = node.data.type;
+		if (type !== null && type !== void 0 && type !== "normal") continue;
+		if (node.data.initialId && nodeIds.has(node.data.initialId)) continue;
+		const firstChild = childrenByParentId.get(node.id)?.[0];
+		if (!firstChild) continue;
+		node.data.initialId = firstChild.id;
+		if ("initialNodeId" in node) node.initialNodeId = firstChild.id;
+	}
+}
+function toArray(value) {
+	return Array.isArray(value) ? value : value === void 0 ? [] : [value];
+}
+function actionItems(value, idPrefix) {
+	return toArray(value).flat().map((item, index) => {
+		if (typeof item === "string") return {
+			id: `${idPrefix}-${index}`,
+			type: item
+		};
+		if (item && typeof item === "object" && "type" in item) {
+			const action = item;
+			if (typeof action.type === "string") return {
+				id: `${idPrefix}-${index}`,
+				type: action.type,
+				params: action.params
+			};
+		}
+		return null;
+	}).filter((item) => item !== null);
+}
+function invokeItems(value) {
+	return toArray(value).map((item, index) => {
+		if (typeof item === "string") return {
+			id: item || `invoke-${index}`,
+			src: item
+		};
+		if (!item || typeof item !== "object") return null;
+		const invoke = item;
+		const srcExpression = isCodeExpression(invoke.src) ? invoke.src : void 0;
+		if (typeof invoke.src !== "string" && !srcExpression) return null;
+		const src = typeof invoke.src === "string" ? invoke.src : "inline:";
+		return {
+			id: typeof invoke.id === "string" ? invoke.id : srcExpression ? `$auto-inline-${index}` : `$auto-invoke-${src || index}`,
+			...typeof invoke.id === "string" ? { invocationId: invoke.id } : {},
+			src,
+			...srcExpression ? { srcExpression } : {},
+			...typeof invoke.registryKey === "string" ? { registryKey: invoke.registryKey } : {},
+			...invoke.timeout !== void 0 ? { timeout: invoke.timeout } : {},
+			...invoke.input !== void 0 ? { input: invoke.input } : {},
+			...invoke.output !== void 0 ? { output: invoke.output } : {}
+		};
+	}).filter((item) => item !== null);
+}
+function transitionTargets(target) {
+	if (typeof target === "string") return [target];
+	if (Array.isArray(target)) return target.filter((item) => typeof item === "string");
+	return [];
+}
+function transitionObjects(value) {
+	return toArray(value).map((item) => {
+		if (typeof item === "string") return { target: item };
+		if (item && typeof item === "object") return item;
+		return {};
+	});
+}
+function guardObject(value) {
+	if (!value) return null;
+	if (typeof value === "string") return { type: value };
+	if (typeof value === "object" && "type" in value && typeof value.type === "string") {
+		const guard = value;
+		return {
+			type: guard.type,
+			code: guard.code,
+			params: guard.params
+		};
+	}
+	return null;
+}
+function implementationItems(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+	return Object.entries(value).map(([name, body]) => ({
+		id: name,
+		name,
+		description: null,
+		paramsSchema: null,
+		code: typeof body === "string" || typeof body === "number" ? {
+			body: String(body),
+			lang: "ts"
+		} : isCodeExpression(body) ? {
+			body: body.expr,
+			lang: body.lang,
+			imports: body.imports
+		} : null
+	}));
+}
+function actorImplementationItems(value) {
+	return implementationItems(value).map((item) => ({
+		...item,
+		inputSchema: null,
+		outputSchema: null
+	}));
+}
+function machineConfigToGraph(config, options = {}) {
+	const rootState = config;
+	const rootConfig = config;
+	const rootKey = String(rootState.id ?? "machine");
+	const graph = {
+		id: "root",
+		nodes: [],
+		edges: [],
+		data: {
+			profile: normalizeProfileRef(options.profile ?? XSTATE_V5_PROFILE),
+			version: typeof rootConfig.version === "string" ? rootConfig.version : null,
+			options: rootConfig.options && typeof rootConfig.options === "object" && !Array.isArray(rootConfig.options) ? rootConfig.options : null,
+			internalEvents: Array.isArray(rootConfig.internalEvents) ? rootConfig.internalEvents.filter((event) => typeof event === "string") : null,
+			context: rootConfig.context && typeof rootConfig.context === "object" ? rootConfig.context : null,
+			implementations: {
+				actions: implementationItems(rootConfig.actions),
+				guards: implementationItems(rootConfig.guards),
+				actors: actorImplementationItems(rootConfig.actors ?? rootConfig.actorSources),
+				delays: implementationItems(rootConfig.delays)
+			},
+			schemas: config.schemas ?? null
+		}
+	};
+	const stateByGraphId = /* @__PURE__ */ new Map();
+	const explicitIdToGraphId = /* @__PURE__ */ new Map();
+	function initialParts(initial) {
+		return typeof initial === "string" ? {
+			target: initial,
+			input: void 0
+		} : initial && typeof initial === "object" ? {
+			target: initial.target,
+			input: initial.input
+		} : {
+			target: void 0,
+			input: void 0
+		};
+	}
+	function collect(state, key, parentId) {
+		const id = parentId ? `${parentId}.${key}` : "root";
+		stateByGraphId.set(id, state);
+		if (state.id) explicitIdToGraphId.set(state.id.replace(/^#/, ""), id);
+		if (!parentId && state.id) explicitIdToGraphId.set(rootKey, id);
+		const initial = initialParts(state.initial);
+		graph.nodes.push({
+			id,
+			parentId,
+			data: {
+				nodeId: state.id ?? null,
+				key,
+				type: state.type === "parallel" || state.type === "final" || state.type === "history" || state.type === "choice" ? state.type : null,
+				initialId: null,
+				...initial.input !== void 0 ? { initialInput: initial.input } : {},
+				...state.timeout !== void 0 ? { timeout: state.timeout } : {},
+				...state.route !== void 0 ? { route: state.route } : {},
+				history: state.history ?? false,
+				...state.output !== void 0 ? { output: state.output } : {},
+				...parentId && state.schemas ? { schemas: state.schemas } : {},
+				entry: actionItems(state.entry, `${id}-entry`),
+				exit: actionItems(state.exit, `${id}-exit`),
+				invokes: invokeItems(state.invoke),
+				tags: Array.isArray(state.tags) ? state.tags : typeof state.tags === "string" ? [state.tags] : [],
+				description: state.description ?? null,
+				meta: state.meta ?? null
+			}
+		});
+		for (const [childKey, child] of Object.entries(state.states ?? {})) collect(child, childKey, id);
+	}
+	collect(rootState, rootKey, null);
+	function targetToNodeId(sourceId, target) {
+		if (!target) return sourceId;
+		if (target === ".") return sourceId;
+		if (target.startsWith(".")) return `${sourceId}${target}`;
+		if (target.startsWith("#")) {
+			const authored = target.slice(1);
+			const matchedId = [...explicitIdToGraphId.keys()].sort((a, b) => b.length - a.length).find((candidate) => authored === candidate || authored.startsWith(`${candidate}.`));
+			if (matchedId) {
+				const suffix = authored.slice(matchedId.length);
+				return `${explicitIdToGraphId.get(matchedId)}${suffix}`;
+			}
+			const rootPrefix = `${rootKey}.`;
+			const path = authored.startsWith(rootPrefix) ? authored.slice(rootPrefix.length) : authored;
+			return path ? `root.${path}` : "root";
+		}
+		return `${sourceId.split(".").slice(0, -1).join(".") || "root"}.${target}`;
+	}
+	function initialTargetToNodeId(sourceId, target) {
+		if (!target) return null;
+		if (target.startsWith("#")) return targetToNodeId(sourceId, target);
+		return `${sourceId}.${target.replace(/^\./, "")}`;
+	}
+	for (const node of graph.nodes) {
+		const state = stateByGraphId.get(node.id);
+		const historyTarget = transitionTargets(state.target)[0];
+		node.data.initialId = state.type === "history" ? historyTarget ? targetToNodeId(node.id, historyTarget) : null : initialTargetToNodeId(node.id, initialParts(state.initial).target);
+	}
+	applyDefaultInitialIds(graph.nodes);
+	function doneStateEventType(eventType) {
+		if (!eventType.startsWith("xstate.done.state.")) return null;
+		const stateId = eventType.slice(18);
+		const graphId = explicitIdToGraphId.get(stateId);
+		if (graphId) return `@statelyai.state.done.${graphId}`;
+		if (stateByGraphId.has(stateId)) return `@statelyai.state.done.${stateId}`;
+		const rootPrefix = `${rootKey}.`;
+		if (stateId.startsWith(rootPrefix)) {
+			const mapped = `root.${stateId.slice(rootPrefix.length)}`;
+			if (stateByGraphId.has(mapped)) return `@statelyai.state.done.${mapped}`;
+		}
+		return null;
+	}
+	/**
+	* `on: { 'xstate.done.actor.<invokeId>': ... }` is the same edge the exporter
+	* writes back as the invoke's `onDone`/`onError`, so it is stored as the
+	* canonical internal reference. Otherwise the two encodings do not
+	* round-trip.
+	*/
+	function invokeActorEventType(state, eventType) {
+		const match = /^xstate\.(done|error)\.actor\.(.+)$/.exec(eventType);
+		const snapshotMatch = /^xstate\.snapshot(?:\.actor)?\.(.+)$/.exec(eventType);
+		if (!match && !snapshotMatch) return null;
+		const verb = match?.[1] ?? "snapshot";
+		const actorId = match?.[2] ?? snapshotMatch?.[1];
+		const invoke = invokeItems(state.invoke).find((item) => item.invocationId === actorId);
+		if (!invoke) return null;
+		return `@statelyai.invoke.${verb}.${invoke.id}`;
+	}
+	function addTransitions(sourceId, value, eventType, idPrefix, extraData = {}) {
+		for (const [index, transition] of transitionObjects(value).entries()) {
+			const targets = transitionTargets(transition.target);
+			const target = targets[0];
+			const edgeId = `${sourceId}-${idPrefix}-${index}`;
+			graph.edges.push({
+				id: edgeId,
+				sourceId,
+				targetId: targetToNodeId(sourceId, target),
+				data: {
+					eventType,
+					...targets.length > 1 ? { additionalTargetIds: targets.slice(1).map((item) => targetToNodeId(sourceId, item)) } : {},
+					...transition.matches && typeof transition.matches === "object" ? { matches: transition.matches } : {},
+					transitionType: target ? transition.reenter ? "reenter" : "normal" : "targetless",
+					guard: guardObject(transition.guard),
+					...transition.context !== void 0 ? { context: transition.context } : {},
+					...transition.input !== void 0 ? { input: transition.input } : {},
+					actions: actionItems(transition.actions, `${edgeId}-actions`),
+					description: transition.meta && typeof transition.meta === "object" && Object.prototype.hasOwnProperty.call(transition.meta, XSTATE_V6_BRANCH_DESCRIPTION_META) ? typeof transition.meta[XSTATE_V6_BRANCH_DESCRIPTION_META] === "string" ? transition.meta[XSTATE_V6_BRANCH_DESCRIPTION_META] : null : typeof transition.description === "string" ? transition.description : null,
+					meta: transition.meta && typeof transition.meta === "object" ? transition.meta : null,
+					...extraData
+				}
+			});
+		}
+	}
+	for (const node of graph.nodes) {
+		const id = node.id;
+		const state = stateByGraphId.get(id);
+		for (const [eventType, value] of Object.entries(state.on ?? {})) addTransitions(id, value, doneStateEventType(eventType) ?? invokeActorEventType(state, eventType) ?? eventType, eventType);
+		for (const [delay, value] of Object.entries(state.after ?? {})) addTransitions(id, value, `xstate.after.${delay}.${id}`, `after-${delay}`);
+		addTransitions(id, state.always, "", "always");
+		addTransitions(id, state.choice, "", "choice");
+		addTransitions(id, state.onDone, `@statelyai.state.done.${id}`, "state-done");
+		addTransitions(id, state.onError, `@statelyai.state.error.${id}`, "state-error");
+		addTransitions(id, state.onTimeout, `@statelyai.state.timeout.${id}`, "state-timeout");
+		const invokes = invokeItems(state.invoke);
+		for (const [invokeIndex, rawInvoke] of toArray(state.invoke).entries()) {
+			if (!rawInvoke || typeof rawInvoke !== "object") continue;
+			const invoke = invokes[invokeIndex];
+			if (!invoke) continue;
+			const invokeConfig = rawInvoke;
+			for (const [slot, refSlot] of [
+				["onDone", "done"],
+				["onError", "error"],
+				["onSnapshot", "snapshot"],
+				["onTimeout", "timeout"]
+			]) addTransitions(id, invokeConfig[slot], `@statelyai.invoke.${refSlot}.${invoke.id}`, `invoke-${invoke.id}-${refSlot}`);
+		}
+	}
+	for (const node of graph.nodes) {
+		if (node.id === "root" || node.data.route === void 0) continue;
+		const route = node.data.route;
+		addTransitions("root", {
+			...isCodeExpression(route) ? {} : route && typeof route === "object" ? route : {},
+			target: `#${node.data.nodeId ?? node.id}`
+		}, "xstate.route", `route-${node.id}`, { route: true });
+	}
+	return graph;
+}
+function graphToNormalizedMachine(graph) {
+	return graphToMachineConfig(graph);
+}
+
+//#endregion
+export { graphToNormalizedMachine as a, normalizeProfileRef as c, graphToMachineConfig as i, stripExportDefault as l, getDelayKeyFromEventType as n, machineConfigToGraph as o, getResolvedNodeId as r, machineGraph_exports as s, applyDefaultInitialIds as t };