@rsconcept/rstool 0.10.3 → 1.0.1

package/dist/models-Bw6Uum8i.js

@@ -0,0 +1,685 @@
+import { CstType } from "./models/common.js";
+import { ModelAdapter } from "./mappers/model-adapter.js";
+import { SchemaAdapter } from "./mappers/schema-adapter.js";
+import { CONTRACT_VERSION } from "./models/tool-contract.js";
+import { Graph } from "@rsconcept/domain/graph/graph";
+import { extractGlobals } from "@rsconcept/domain/rslang/api";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/models/portal-json.ts
+const CST_TYPE_VALUES = new Set(Object.values(CstType));
+function parsePortalCstType(value, alias) {
+	if (!CST_TYPE_VALUES.has(value)) throw new Error(`Invalid cst_type "${value}" for constituent "${alias}"`);
+	return value;
+}
+/** Portal JSON import/export format version (schema and model files). */
+const PORTAL_JSON_CONTRACT_VERSION = "1.0.0";
+/** Map a Portal API or JSON schema item to an agent {@link ConstituentaDraft}. */
+function portalItemToDraft(item) {
+	return {
+		id: item.id,
+		alias: item.alias,
+		cstType: parsePortalCstType(item.cst_type, item.alias),
+		definitionFormal: item.definition_formal ?? "",
+		term: item.term_raw ?? "",
+		definitionText: item.definition_raw ?? "",
+		convention: item.convention ?? ""
+	};
+}
+//#endregion
+//#region src/mappers/portal-adapter.ts
+function portalMetadataToSessionSeed(data) {
+	return {
+		alias: data.alias ?? "",
+		title: data.title ?? "",
+		comment: data.description ?? "",
+		items: []
+	};
+}
+function portalSchemaToSessionSeed(data) {
+	return portalMetadataToSessionSeed(data);
+}
+function portalDetailsToSessionSeed(data) {
+	return portalMetadataToSessionSeed(data);
+}
+function portalItemsToDrafts(items) {
+	return items.map((item) => portalItemToDraft(item));
+}
+function portalSchemaToDrafts(data) {
+	return portalItemsToDrafts(data.items);
+}
+function portalDetailsToDrafts(data) {
+	return portalItemsToDrafts(data.items);
+}
+//#endregion
+//#region src/session/batch-apply.ts
+/** Order drafts so suppliers are applied before dependents. */
+function orderDrafts(sessionItems, drafts) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const item of sessionItems) merged.set(item.id, {
+		id: item.id,
+		alias: item.alias,
+		cstType: item.cstType,
+		definitionFormal: item.definitionFormal
+	});
+	for (const draft of drafts) merged.set(draft.id, draft);
+	const graph = new Graph();
+	const aliasToId = /* @__PURE__ */ new Map();
+	for (const [id, draft] of merged) {
+		graph.addNode(id);
+		aliasToId.set(draft.alias, id);
+	}
+	for (const [id, draft] of merged) {
+		if (!draft.definitionFormal) continue;
+		for (const alias of extractGlobals(draft.definitionFormal)) {
+			const depId = aliasToId.get(alias);
+			if (depId !== void 0 && depId !== id) graph.addEdge(depId, id);
+		}
+	}
+	const draftIds = new Set(drafts.map((draft) => draft.id));
+	const topoIds = graph.topologicalOrder().filter((id) => draftIds.has(id));
+	const seen = new Set(topoIds);
+	const missing = drafts.filter((draft) => !seen.has(draft.id)).map((draft) => draft.id);
+	return [...topoIds, ...missing].map((id) => drafts.find((draft) => draft.id === id)).filter(Boolean);
+}
+/**
+* Restore declaration order in session items after a batch apply.
+* Topological apply order is only needed for analysis; Portal JSON uses array order.
+*/
+function reorderSessionItemsByDrafts(items, drafts) {
+	if (drafts.length === 0 || items.length === 0) return;
+	const draftIds = drafts.map((draft) => draft.id);
+	const draftIdSet = new Set(draftIds);
+	if (items.filter((item) => draftIdSet.has(item.id)).length === 0) return;
+	const unmentioned = items.filter((item) => !draftIdSet.has(item.id));
+	if (unmentioned.length === 0) {
+		const byId = new Map(items.map((item) => [item.id, item]));
+		items.splice(0, items.length, ...draftIds.map((id) => byId.get(id)));
+		return;
+	}
+	const existingIds = new Set(unmentioned.map((item) => item.id));
+	const newDrafts = drafts.filter((draft) => !existingIds.has(draft.id));
+	if (newDrafts.length === 0) return;
+	const newIds = new Set(newDrafts.map((draft) => draft.id));
+	const kept = items.filter((item) => !newIds.has(item.id));
+	const byId = new Map(items.map((item) => [item.id, item]));
+	items.splice(0, items.length, ...kept, ...newDrafts.map((draft) => byId.get(draft.id)));
+}
+//#endregion
+//#region src/session/persistence.ts
+const CURRENT_SESSION_FILE = "_current.json";
+const UNSAFE_SESSION_ID = /[/\\]|\.\./;
+function assertSafeSessionId(sessionId) {
+	if (!sessionId || UNSAFE_SESSION_ID.test(sessionId)) throw new Error(`Invalid session ID: ${sessionId}`);
+}
+var SessionPersistence = class {
+	dir;
+	constructor(dir) {
+		this.dir = dir;
+		fs.mkdirSync(dir, { recursive: true });
+	}
+	save(sessionId, envelope) {
+		fs.writeFileSync(this.filePath(sessionId), JSON.stringify(envelope, null, 2), "utf-8");
+	}
+	load(sessionId) {
+		const file = this.filePath(sessionId);
+		if (!fs.existsSync(file)) return null;
+		return JSON.parse(fs.readFileSync(file, "utf-8"));
+	}
+	delete(sessionId) {
+		const file = this.filePath(sessionId);
+		if (fs.existsSync(file)) fs.unlinkSync(file);
+	}
+	saveCurrentSessionId(sessionId) {
+		fs.writeFileSync(path.join(this.dir, CURRENT_SESSION_FILE), JSON.stringify({ sessionId }, null, 2), "utf-8");
+	}
+	loadCurrentSessionId() {
+		const file = path.join(this.dir, CURRENT_SESSION_FILE);
+		if (!fs.existsSync(file)) return null;
+		return JSON.parse(fs.readFileSync(file, "utf-8")).sessionId ?? null;
+	}
+	filePath(sessionId) {
+		assertSafeSessionId(sessionId);
+		const file = path.resolve(this.dir, `${sessionId}.json`);
+		const relative = path.relative(path.resolve(this.dir), file);
+		if (relative.startsWith("..") || path.isAbsolute(relative)) throw new Error(`Invalid session ID: ${sessionId}`);
+		return file;
+	}
+};
+//#endregion
+//#region src/session/session-store.ts
+var SessionStore = class {
+	sessions = /* @__PURE__ */ new Map();
+	persistence;
+	constructor(options = {}) {
+		this.persistence = options.persistenceDir ? new SessionPersistence(options.persistenceDir) : null;
+	}
+	create(initial, contractVersion) {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const sessionId = initial?.sessionId ?? randomUUID();
+		const envelope = {
+			state: {
+				sessionId,
+				alias: initial?.alias ?? "",
+				title: initial?.title ?? "",
+				comment: initial?.comment ?? "",
+				createdAt: initial?.createdAt ?? now,
+				updatedAt: now,
+				revisions: initial?.revisions ?? [],
+				items: initial?.items ?? [],
+				model: initial?.model ?? { items: [] }
+			},
+			diagnostics: []
+		};
+		this.sessions.set(sessionId, envelope);
+		this.persist(sessionId, envelope);
+		return {
+			sessionId,
+			contractVersion: contractVersion ?? "2.0.0"
+		};
+	}
+	get(sessionId) {
+		const found = this.sessions.get(sessionId) ?? this.loadFromDisk(sessionId);
+		if (!found) throw new Error(`Unknown session: ${sessionId}`);
+		return found;
+	}
+	has(sessionId) {
+		if (this.sessions.has(sessionId)) return true;
+		if (!this.persistence) return false;
+		return this.persistence.load(sessionId) !== null;
+	}
+	replaceState(sessionId, nextState) {
+		const found = this.get(sessionId);
+		found.state = {
+			...nextState,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		this.persist(sessionId, found);
+	}
+	addRevision(sessionId, message) {
+		const found = this.get(sessionId);
+		const revision = {
+			revisionId: randomUUID(),
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			message
+		};
+		found.state.revisions.push(revision);
+		found.state.updatedAt = revision.at;
+		this.persist(sessionId, found);
+		return revision;
+	}
+	/** Replace active diagnostics for one constituent (or scratch when constituentId is undefined). */
+	replaceDiagnosticsForConstituent(sessionId, constituentId, records) {
+		const found = this.get(sessionId);
+		found.diagnostics = found.diagnostics.filter((record) => record.constituentId !== constituentId);
+		found.diagnostics.push(...records);
+		found.state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		this.persist(sessionId, found);
+	}
+	setDiagnostics(sessionId, records) {
+		const found = this.get(sessionId);
+		found.diagnostics = [...records];
+		found.state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		this.persist(sessionId, found);
+	}
+	listDiagnostics(sessionId, filters) {
+		const found = this.get(sessionId);
+		if (filters?.constituentId === void 0) return [...found.diagnostics];
+		return found.diagnostics.filter((record) => record.constituentId === filters.constituentId);
+	}
+	snapshot(sessionId) {
+		const found = this.get(sessionId);
+		return structuredClone(found);
+	}
+	restore(sessionId, snapshot) {
+		this.sessions.set(sessionId, structuredClone(snapshot));
+		this.persist(sessionId, this.sessions.get(sessionId));
+	}
+	saveCurrentSessionId(sessionId) {
+		this.persistence?.saveCurrentSessionId(sessionId);
+	}
+	loadCurrentSessionId() {
+		return this.persistence?.loadCurrentSessionId() ?? null;
+	}
+	loadFromDisk(sessionId) {
+		const loaded = this.persistence?.load(sessionId);
+		if (!loaded) return null;
+		this.sessions.set(sessionId, loaded);
+		return loaded;
+	}
+	persist(sessionId, envelope) {
+		this.persistence?.save(sessionId, envelope);
+	}
+};
+//#endregion
+//#region src/models/import-detect.ts
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseImportPayload(payload) {
+	if (typeof payload === "string") return JSON.parse(payload);
+	return payload;
+}
+function detectImportKind(data) {
+	if (!isRecord(data)) throw new Error("Invalid import payload");
+	if ("contractVersion" in data && "state" in data) return "session";
+	if ("contract_version" in data && Array.isArray(data.items)) {
+		const items = data.items;
+		if (items.length > 0) {
+			const first = items[0];
+			if (isRecord(first) && "cst_type" in first) return "portal-schema";
+			throw new Error("Portal model JSON cannot be imported as a schema session");
+		}
+	}
+	if (Array.isArray(data.items) && data.items.length > 0) {
+		const first = data.items[0];
+		if (isRecord(first) && "cst_type" in first) return "portal-details";
+	}
+	throw new Error("Cannot detect import kind; pass kind explicitly");
+}
+//#endregion
+//#region src/models/rstool-agent.ts
+function normalizeImportedState(state) {
+	return {
+		...state,
+		alias: state.alias ?? "",
+		title: state.title ?? "",
+		comment: state.comment ?? "",
+		model: state.model ?? { items: [] }
+	};
+}
+function portalImportMetadata(session, kind) {
+	const defaults = kind === "schema" ? {
+		title: "Conceptual schema",
+		alias: "SCHEMA"
+	} : {
+		title: "Conceptual model",
+		alias: "MODEL"
+	};
+	const title = session.title.trim();
+	const alias = session.alias.trim();
+	return {
+		title: title.length > 0 ? title : defaults.title,
+		alias: alias.length > 0 ? alias : defaults.alias,
+		description: session.comment.trim()
+	};
+}
+function inferCstType(alias) {
+	switch (alias.trim().charAt(0).toUpperCase()) {
+		case "X": return CstType.BASE;
+		case "C": return CstType.CONSTANT;
+		case "S": return CstType.STRUCTURED;
+		case "D": return CstType.TERM;
+		case "A": return CstType.AXIOM;
+		case "F": return CstType.FUNCTION;
+		case "P": return CstType.PREDICATE;
+		case "N": return CstType.NOMINAL;
+		case "T": return CstType.STATEMENT;
+		default: throw new Error(`Cannot infer cstType from alias "${alias}"; pass cstType explicitly`);
+	}
+}
+/**
+* Agent-facing entry point for incremental RSForm editing, analysis, diagnostics,
+* modeling, and evaluation.
+*
+* Holds in-memory (optionally persisted) sessions and delegates language work
+* to internal schema and model adapters.
+*/
+var RSToolAgent = class {
+	contractVersion = CONTRACT_VERSION;
+	sessions;
+	adapter = new SchemaAdapter();
+	evaluation = new ModelAdapter();
+	currentSessionId;
+	/** @param options - Optional persistence directory for session storage. */
+	constructor(options = {}) {
+		this.sessions = new SessionStore({ persistenceDir: options.persistenceDir });
+		this.currentSessionId = this.sessions.loadCurrentSessionId();
+	}
+	/** @inheritdoc */
+	ensureSession(initial) {
+		return this.getCurrentSession() ?? this.createSession(initial);
+	}
+	/** @inheritdoc */
+	createSession(initial) {
+		return this.trackSession(this.sessions.create(initial, this.contractVersion));
+	}
+	/** @inheritdoc */
+	getCurrentSession() {
+		if (!this.currentSessionId) return null;
+		if (!this.sessions.has(this.currentSessionId)) {
+			this.currentSessionId = null;
+			this.sessions.saveCurrentSessionId(null);
+			return null;
+		}
+		return {
+			sessionId: this.currentSessionId,
+			contractVersion: this.contractVersion
+		};
+	}
+	/** @inheritdoc */
+	setCurrentSession(sessionId) {
+		if (!this.sessions.has(sessionId)) throw new Error(`Unknown session: ${sessionId}`);
+		return this.trackSession({
+			sessionId,
+			contractVersion: this.contractVersion
+		});
+	}
+	/** @inheritdoc */
+	applySchemaPatch(input, sessionId) {
+		const session = sessionId ? {
+			sessionId: this.resolveSessionId(sessionId),
+			contractVersion: this.contractVersion
+		} : this.ensureSession(input.initial);
+		const drafts = this.resolveAgentPatches(session.sessionId, input.items);
+		const result = this.applyConstituents({
+			drafts,
+			mode: input.mode
+		}, session.sessionId);
+		const revision = result.success && input.commitMessage ? this.commitStep(input.commitMessage, session.sessionId) : void 0;
+		return {
+			...result,
+			session,
+			summary: this.buildSessionSummary(session.sessionId),
+			revision
+		};
+	}
+	/** @inheritdoc */
+	getSessionState(detail = "summary", sessionId) {
+		if (detail === "full") {
+			const envelope = this.sessions.get(this.resolveSessionId(sessionId));
+			return structuredClone(envelope.state);
+		}
+		return this.buildSessionSummary(sessionId);
+	}
+	/** @inheritdoc */
+	listDiagnostics(filters, sessionId) {
+		return this.sessions.listDiagnostics(this.resolveSessionId(sessionId), filters);
+	}
+	/** @inheritdoc */
+	analyzeExpression(input, sessionId) {
+		const id = this.resolveSessionId(sessionId);
+		const envelope = this.sessions.get(id);
+		const { result, diagnostics } = this.adapter.analyzeAgainstSession(envelope.state, {
+			id: -1,
+			alias: "_analysis",
+			cstType: input.cstType,
+			definitionFormal: input.expression
+		});
+		if (input.recordDiagnostics) this.sessions.replaceDiagnosticsForConstituent(id, void 0, diagnostics.map((item) => ({
+			...item,
+			constituentId: void 0
+		})));
+		return result;
+	}
+	/** @inheritdoc */
+	commitStep(message, sessionId) {
+		return this.sessions.addRevision(this.resolveSessionId(sessionId), message);
+	}
+	/** @inheritdoc */
+	exportSession(sessionId) {
+		const envelope = this.sessions.get(this.resolveSessionId(sessionId));
+		return JSON.stringify({
+			contractVersion: this.contractVersion,
+			state: envelope.state,
+			diagnostics: envelope.diagnostics
+		}, null, 2);
+	}
+	/** @inheritdoc */
+	exportPortal(input, sessionId) {
+		const format = input.format ?? "json";
+		const object = input.kind === "schema" ? this.buildPortalSchemaObject(sessionId) : this.buildPortalModelObject(sessionId);
+		return format === "object" ? object : JSON.stringify(object, null, 2);
+	}
+	/** @inheritdoc */
+	importData(payload, kind = "auto") {
+		const parsed = parseImportPayload(payload);
+		const resolvedKind = kind === "auto" ? detectImportKind(parsed) : kind;
+		switch (resolvedKind) {
+			case "session": return this.importSessionExport(parsed);
+			case "portal-schema": return this.importPortalSchemaData(parsed);
+			case "portal-details": return this.importPortalDetailsData(parsed);
+			default: throw new Error(`Unsupported import kind: ${resolvedKind}`);
+		}
+	}
+	/** @inheritdoc */
+	async setModelValues(input, sessionId) {
+		const id = this.resolveSessionId(sessionId);
+		const snapshot = this.sessions.snapshot(id);
+		try {
+			let state = this.sessions.get(id).state;
+			if (input.clear?.length) {
+				const model = await this.evaluation.clearConstituentaValues(state, input.clear);
+				state = {
+					...state,
+					model
+				};
+				this.sessions.replaceState(id, state);
+			}
+			if (input.set?.length) {
+				state = this.sessions.get(id).state;
+				const model = await this.evaluation.setConstituentaValues(state, { items: input.set });
+				state = {
+					...state,
+					model
+				};
+				this.sessions.replaceState(id, state);
+				return model;
+			}
+			return structuredClone(this.sessions.get(id).state.model);
+		} catch (error) {
+			this.sessions.restore(id, snapshot);
+			throw error;
+		}
+	}
+	/** @inheritdoc */
+	getModelState(sessionId) {
+		const envelope = this.sessions.get(this.resolveSessionId(sessionId));
+		return structuredClone(envelope.state.model);
+	}
+	/** @inheritdoc */
+	evaluate(input, sessionId) {
+		const envelope = this.sessions.get(this.resolveSessionId(sessionId));
+		if (input.constituentId !== void 0) return this.evaluation.evaluateConstituenta(envelope.state, input.constituentId);
+		if (input.expression !== void 0 && input.cstType !== void 0) return this.evaluation.evaluateExpression(envelope.state, input.expression, input.cstType);
+		throw new Error("evaluate requires constituentId or expression with cstType");
+	}
+	/** @inheritdoc */
+	recalculateModel(sessionId) {
+		const envelope = this.sessions.get(this.resolveSessionId(sessionId));
+		return this.evaluation.recalculateModel(envelope.state);
+	}
+	addOrUpdateConstituenta(input, sessionId) {
+		const id = this.resolveSessionId(sessionId);
+		const envelope = this.sessions.get(id);
+		const { result, diagnostics } = this.adapter.analyzeAgainstSession(envelope.state, input.draft);
+		const state = this.adapter.mergeStateWithDraft(envelope.state, input.draft, result);
+		this.sessions.replaceDiagnosticsForConstituent(id, input.draft.id, diagnostics);
+		return {
+			state,
+			diagnostics
+		};
+	}
+	applyConstituents(input, sessionId) {
+		const id = this.resolveSessionId(sessionId);
+		const mode = input.mode ?? "atomic";
+		const ordered = orderDrafts(this.sessions.get(id).state.items, input.drafts);
+		const snapshot = this.sessions.snapshot(id);
+		const applied = [];
+		const failed = [];
+		for (const draft of ordered) {
+			const result = this.addOrUpdateConstituenta({ draft }, id);
+			if (result.state.analysis.success) {
+				applied.push(result.state);
+				continue;
+			}
+			failed.push({
+				draft,
+				diagnostics: result.diagnostics
+			});
+			if (mode === "atomic") {
+				this.sessions.restore(id, snapshot);
+				return {
+					success: false,
+					applied: [],
+					failed,
+					diagnostics: this.sessions.listDiagnostics(id)
+				};
+			}
+		}
+		const envelope = this.sessions.get(id);
+		reorderSessionItemsByDrafts(envelope.state.items, input.drafts);
+		this.sessions.replaceState(id, envelope.state);
+		return {
+			success: failed.length === 0,
+			applied,
+			failed,
+			diagnostics: this.sessions.listDiagnostics(id)
+		};
+	}
+	buildSessionSummary(sessionId) {
+		const id = this.resolveSessionId(sessionId);
+		const envelope = this.sessions.get(id);
+		const diagnostics = this.sessions.listDiagnostics(id);
+		return {
+			sessionId: id,
+			contractVersion: this.contractVersion,
+			alias: envelope.state.alias,
+			title: envelope.state.title,
+			comment: envelope.state.comment,
+			itemCount: envelope.state.items.length,
+			modelItemCount: envelope.state.model.items.length,
+			diagnosticsCount: diagnostics.length,
+			items: envelope.state.items.map((item) => ({
+				id: item.id,
+				alias: item.alias,
+				cstType: item.cstType,
+				analysisSuccess: item.analysis.success
+			})),
+			diagnostics,
+			lastRevision: envelope.state.revisions.at(-1)
+		};
+	}
+	buildPortalSchemaObject(sessionId) {
+		const envelope = this.sessions.get(this.resolveSessionId(sessionId));
+		return {
+			contract_version: PORTAL_JSON_CONTRACT_VERSION,
+			...portalImportMetadata(envelope.state, "schema"),
+			items: envelope.state.items.map((item) => ({
+				id: item.id,
+				alias: item.alias,
+				convention: item.convention,
+				crucial: false,
+				cst_type: item.cstType,
+				definition_formal: item.definitionFormal,
+				typification_manual: "",
+				value_is_property: false,
+				definition_raw: item.definitionText,
+				definition_resolved: item.definitionText,
+				term_raw: item.term,
+				term_resolved: item.term,
+				term_forms: []
+			})),
+			attribution: []
+		};
+	}
+	buildPortalModelObject(sessionId) {
+		const envelope = this.sessions.get(this.resolveSessionId(sessionId));
+		return {
+			contract_version: PORTAL_JSON_CONTRACT_VERSION,
+			...portalImportMetadata(envelope.state, "model"),
+			items: envelope.state.model.items.map((item) => ({
+				id: item.id,
+				type: item.type,
+				value: item.value
+			}))
+		};
+	}
+	importSessionExport(parsed) {
+		if (!parsed || typeof parsed !== "object" || !("state" in parsed)) throw new Error("Invalid session export payload");
+		const data = parsed;
+		const handle = this.sessions.create(normalizeImportedState(data.state), this.contractVersion);
+		if (data.diagnostics?.length) this.sessions.setDiagnostics(handle.sessionId, data.diagnostics);
+		return this.trackSession(handle);
+	}
+	importPortalSchemaData(data) {
+		const handle = this.createSession(portalSchemaToSessionSeed(data));
+		this.applyConstituents({
+			drafts: portalSchemaToDrafts(data),
+			mode: "best_effort"
+		}, handle.sessionId);
+		return handle;
+	}
+	importPortalDetailsData(data) {
+		const handle = this.createSession(portalDetailsToSessionSeed(data));
+		this.applyConstituents({
+			drafts: portalDetailsToDrafts(data),
+			mode: "best_effort"
+		}, handle.sessionId);
+		return handle;
+	}
+	resolveAgentPatches(sessionId, patches) {
+		const items = this.sessions.get(sessionId).state.items;
+		const existingByAlias = new Map(items.map((item) => [item.alias, item]));
+		const usedIds = new Set(items.map((item) => item.id));
+		let nextId = items.reduce((max, item) => Math.max(max, item.id), 0) + 1;
+		const reserveId = (id) => {
+			usedIds.add(id);
+			if (id >= nextId) nextId = id + 1;
+		};
+		const allocateId = () => {
+			while (usedIds.has(nextId)) nextId += 1;
+			const id = nextId;
+			nextId += 1;
+			usedIds.add(id);
+			return id;
+		};
+		return patches.map((patch) => {
+			const existing = existingByAlias.get(patch.alias);
+			let id;
+			if (patch.id !== void 0) {
+				id = patch.id;
+				reserveId(id);
+			} else if (existing !== void 0) id = existing.id;
+			else id = allocateId();
+			const draft = {
+				id,
+				alias: patch.alias,
+				cstType: patch.cstType ?? existing?.cstType ?? inferCstType(patch.alias),
+				definitionFormal: patch.definitionFormal ?? existing?.definitionFormal ?? "",
+				term: patch.term ?? existing?.term ?? "",
+				definitionText: patch.definitionText ?? existing?.definitionText ?? "",
+				convention: patch.convention ?? existing?.convention ?? ""
+			};
+			existingByAlias.set(patch.alias, {
+				...draft,
+				analysis: existing?.analysis ?? {
+					success: true,
+					type: null,
+					valueClass: "value",
+					diagnostics: []
+				}
+			});
+			return draft;
+		});
+	}
+	resolveSessionId(sessionId) {
+		const id = sessionId ?? this.currentSessionId;
+		if (!id) return this.createSession().sessionId;
+		if (!this.sessions.has(id)) {
+			if (sessionId) throw new Error(`Unknown session: ${sessionId}`);
+			return this.createSession().sessionId;
+		}
+		return id;
+	}
+	trackSession(handle) {
+		this.currentSessionId = handle.sessionId;
+		this.sessions.saveCurrentSessionId(handle.sessionId);
+		return handle;
+	}
+};
+//#endregion
+export { portalItemToDraft as i, SessionStore as n, PORTAL_JSON_CONTRACT_VERSION as r, RSToolAgent as t };
+
+//# sourceMappingURL=models-Bw6Uum8i.js.map