statelyai 0.13.0 → 0.14.1

package/README.md

@@ -32,6 +32,8 @@ npm install --global statelyai
 | Set up local discovery              | `statelyai init --local --scan`                      | Local `statelyai.json`                                  |
 | Set up project sync                 | `statelyai init --scan`                              | Remote project and local `statelyai.json`               |
 | Inspect project machines            | `statelyai status`                                   | Nothing                                                 |
+| Connect to a Studio project          | `statelyai link --project <id>`                      | Project association in `statelyai.json`                  |
+| Associate an existing machine       | `statelyai link <file> --machine <id>`               | Selected source machine ID comment                      |
 | Preview project uploads             | `statelyai push --dry-run`                           | Nothing                                                 |
 | Upload local machines               | `statelyai push [file]`                              | Remote machines and local `@statelyai` IDs              |
 | Download project machines           | `statelyai pull`                                     | Linked local files and new files under `newMachinesDir` |
@@ -40,7 +42,7 @@ npm install --global statelyai
 
 ## Quick start
 
-<!-- project initialization and sync flow from InitCommand, PushCommand, PullCommand, and projectConfig.ts -->
+<!-- project initialization and sync flow from InitCommand, LinkCommand, PushCommand, PullCommand, and projectConfig.ts -->
 
 For hosted Stately, authenticate once:
 
@@ -48,10 +50,11 @@ For hosted Stately, authenticate once:
 statelyai login
 ```
 
-Initialize the current repository and scan for XState files:
+Initialize local discovery, then choose the Studio project:
 
 ```bash
-statelyai init --scan
+statelyai init --local --scan
+statelyai link --project <project-id-or-url>
 ```
 
 `--scan` suggests `include` globs and asks before saving them. Without
@@ -66,8 +69,8 @@ statelyai init --local --scan
 statelyai status
 ```
 
-Run `statelyai init` later to connect the local config to a Studio project
-without losing its discovery globs.
+Run `statelyai link` later to choose a Studio project without losing discovery
+globs. Plain `init` still supports the existing connected setup for compatibility.
 
 To list machines without creating any config:
 
@@ -114,6 +117,67 @@ migrated to the shared machine key on the next save.
 New states keep their generated coordinates when clear, or move beside
 existing states when they would overlap restored layout.
 
+## Local setup and Studio linking
+
+<!-- association workflow from src/link.ts and LinkCommand in src/cli.ts -->
+
+Local configuration, Studio association, and data sync are separate steps:
+
+```bash
+statelyai init --local --scan
+statelyai login
+statelyai link --project <project-id-or-url>
+statelyai push --dry-run
+statelyai push
+```
+
+`link` without flags offers a project picker in an interactive terminal. In
+scripts, pass `--project` or explicitly create a project:
+
+```bash
+statelyai link --create --name "Checkout" --visibility Private
+```
+
+Link an existing remote machine to local source without uploading or downloading
+its definition:
+
+```bash
+statelyai link ./test.ts --machine <machine-id-or-url>
+```
+
+The remote machine must belong to the connected project. For a file containing
+multiple machines, select one with `--machine-index 0` (zero-based). This changes
+only the selected machine's `@statelyai id` comment. It does not compare or
+reconcile the two definitions. Review `push --dry-run` and choose `push` or `pull`
+when ready to sync; `linked` describes association, not equality.
+
+Use `--force` to replace an existing project or machine association. Changing the
+project retains existing source machine IDs. `link` preserves discovery globs and
+local writeback settings; it does not scan or include new files automatically.
+Plain `init` retains its existing Studio-connected behavior for compatibility.
+The executable remains `statelyai`.
+
+```mermaid
+stateDiagram-v2
+    [*] --> Unconfigured
+    Unconfigured --> Local: init --local
+    Unconfigured --> Connected: init (compatibility)
+    Unconfigured --> Connected: link
+    Local --> Connected: link
+    state Connected {
+        [*] --> LocalOnly
+        LocalOnly --> Linked: link file --machine (association only)
+        LocalOnly --> Linked: push (create remote + upload + ID)
+        Linked --> Linked: push (upload)
+        Linked --> Linked: pull (download)
+    }
+```
+
+Authentication is independent of this state machine. `open`, `scan`, and
+`push --dry-run` do not establish machine links. `--scan` proposes source globs;
+a new config without it has an empty `include` list. Project-wide `pull` creates
+remote-only files only when `newMachinesDir` is configured.
+
 ## Authentication
 
 <!-- authentication flags, environment resolution, and credential storage from src/cli.ts and src/credentials.ts -->
@@ -252,6 +316,20 @@ Use `--json` for automation or `--auth` to show only credential resolution.
 
 Flags: `--config <path>`, `--base-url <url>`, `--json`, `--auth`.
 
+### `link`
+
+Connect to Studio without moving machine definitions:
+
+```bash
+statelyai link --project <project-id-or-url>
+statelyai link --create --name "Checkout"
+statelyai link ./test.ts --machine <machine-id-or-url>
+```
+
+Flags: `--project <id|url>` or `--create`, `--name`, `--visibility`,
+`--machine <id|url>`, `--machine-index <zero-based-index>`, `--config`,
+`--base-url`, `--force`. See [Local setup and Studio linking](#local-setup-and-studio-linking).
+
 ### `init`
 
 Create a local config or reuse a Studio project and write `statelyai.json`.

package/dist/bin.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { C as run } from "./cli-b1m4txJ7.mjs";
+import { C as run } from "./cli-a0Z1igmj.mjs";
 
 //#region src/bin.ts
 run();

package/dist/{cli-b1m4txJ7.mjs → cli-a0Z1igmj.mjs}

@@ -7,22 +7,23 @@ import { z, z as z$1 } from "zod";
 import { execFile, execFileSync, spawn } from "node:child_process";
 import { promisify } from "node:util";
 import * as crypto from "node:crypto";
+import { randomUUID } from "node:crypto";
+import { StudioApiError, buildAuthorizeUrl, createPkcePair, createStatelyClient, discoverAuthorizationServer, discoverProtectedResource, exchangeCodeForToken, refreshToken, registerOAuthClient } from "@statelyai/sdk";
+import * as ts$1 from "typescript";
+import ts from "typescript";
 import fs, { promises, statSync, watch } from "node:fs";
 import { createInterface } from "node:readline/promises";
 import { Writable } from "node:stream";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import * as http from "node:http";
-import * as ts$1 from "typescript";
-import ts from "typescript";
 import * as fs$1 from "fs";
 import * as path$2 from "path";
 import { fileURLToPath as fileURLToPath$1, pathToFileURL as pathToFileURL$1 } from "url";
 import { fromStudioMachine, toStudioMachine } from "@statelyai/sdk/graph";
 import { EDITOR_PROTOCOL_VERSION } from "@statelyai/sdk/editor-host-protocol";
-import { createStatelyClient, createStatelyClient as createStatelyClient$1$1 } from "@statelyai/sdk/studio";
+import { createStatelyClient as createStatelyClient$1, createStatelyClient as createStatelyClient$1$1 } from "@statelyai/sdk/studio";
 import { WebSocket, WebSocketServer } from "ws";
 import os from "node:os";
-import { StudioApiError, buildAuthorizeUrl, createPkcePair, createStatelyClient as createStatelyClient$1, discoverAuthorizationServer, discoverProtectedResource, exchangeCodeForToken, refreshToken, registerOAuthClient } from "@statelyai/sdk";
 
 //#region \0rolldown/runtime.js
 var __commonJSMin$1 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
@@ -897,6 +898,236 @@ var VerifyCommand = class VerifyCommand extends Command {
 	}
 };
 
+//#endregion
+//#region ../editor-sync/dist/statelyPragma-D46lczJR.mjs
+function findStatelyPragmaAttachments(sourceText, fileName = "machine.ts") {
+	const sourceFile = ts.createSourceFile(fileName, sourceText, ts.ScriptTarget.Latest, true, getScriptKind$4(fileName));
+	const attachments = [];
+	const visit = (node) => {
+		if (ts.isCallExpression(node) && isCreateMachineExpression$3(node.expression)) {
+			const attachNode = findAttachNode(node);
+			if (attachNode) attachments.push({
+				machineStart: getMachineExpressionStart(node.expression, sourceFile),
+				attachStart: attachNode.getStart(sourceFile),
+				pragma: findAttachedStatelyPragma(sourceText, attachNode)
+			});
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return attachments;
+}
+function getStatelyPragma(sourceText, fileName = "machine.ts", machineIndex = 0) {
+	return findStatelyPragmaAttachments(sourceText, fileName)[machineIndex]?.pragma;
+}
+function upsertStatelyPragma(sourceText, id, options = {}) {
+	const attachment = findStatelyPragmaAttachments(sourceText, options.fileName ?? "machine.ts")[options.machineIndex ?? 0];
+	if (!attachment) return sourceText;
+	const lineEnding = options.lineEnding ?? detectLineEnding(sourceText);
+	const canonicalComment = `// @statelyai id=${id}`;
+	if (attachment.pragma) return sourceText.slice(0, attachment.pragma.start) + canonicalComment + sourceText.slice(attachment.pragma.end);
+	const insertText = `${getIndentationAtOffset(sourceText, attachment.attachStart)}${canonicalComment}${lineEnding}`;
+	return sourceText.slice(0, attachment.attachStart) + insertText + sourceText.slice(attachment.attachStart);
+}
+function findAttachedStatelyPragma(sourceText, node) {
+	const comments = ts.getLeadingCommentRanges(sourceText, node.getFullStart()) ?? [];
+	for (let index = comments.length - 1; index >= 0; index -= 1) {
+		const comment = comments[index];
+		const parsed = parseStatelyPragma(sourceText, comment.pos, comment.end);
+		if (parsed) return parsed;
+	}
+}
+function parseStatelyPragma(sourceText, start, end) {
+	const match = normalizeCommentContent(sourceText.slice(start, end)).match(/^@statelyai(?:\s+(.*))?$/s);
+	if (!match) return;
+	const fields = parseFields(match[1] ?? "");
+	return {
+		tag: "@statelyai",
+		id: fields.id,
+		fields,
+		start,
+		end
+	};
+}
+function normalizeCommentContent(rawComment) {
+	if (rawComment.startsWith("//")) return rawComment.slice(2).trim();
+	if (rawComment.startsWith("/*")) return rawComment.slice(2, rawComment.endsWith("*/") ? -2 : void 0).split(/\r?\n/).map((line) => line.replace(/^\s*\*\s?/, "")).join(" ").trim();
+	return rawComment.trim();
+}
+function parseFields(input) {
+	const fields = {};
+	for (const token of input.split(/\s+/)) {
+		if (!token) continue;
+		const equalsIndex = token.indexOf("=");
+		if (equalsIndex <= 0) continue;
+		const key = token.slice(0, equalsIndex);
+		const value = token.slice(equalsIndex + 1);
+		if (!key || !value) continue;
+		fields[key] = value;
+	}
+	return fields;
+}
+function findAttachNode(node) {
+	let current = node;
+	while (current?.parent) {
+		if (ts.isVariableStatement(current.parent) || ts.isExpressionStatement(current.parent) || ts.isExportAssignment(current.parent)) return current.parent;
+		current = current.parent;
+	}
+	return current;
+}
+function isCreateMachineExpression$3(expression) {
+	const isMachineFactoryName = (name) => name === "createMachine" || name === "createMachineFromConfig";
+	return ts.isIdentifier(expression) && isMachineFactoryName(expression.text) || ts.isPropertyAccessExpression(expression) && isMachineFactoryName(expression.name.text);
+}
+function getMachineExpressionStart(expression, sourceFile) {
+	if (ts.isPropertyAccessExpression(expression)) return expression.name.getStart(sourceFile);
+	return expression.getStart(sourceFile);
+}
+function getIndentationAtOffset(sourceText, offset) {
+	const lineStart = sourceText.lastIndexOf("\n", Math.max(0, offset - 1)) + 1;
+	return sourceText.slice(lineStart, offset).match(/^[ \t]*/)?.[0] ?? "";
+}
+function detectLineEnding(sourceText) {
+	return sourceText.includes("\r\n") ? "\r\n" : "\n";
+}
+function getScriptKind$4(fileName) {
+	if (fileName.endsWith(".tsx")) return ts.ScriptKind.TSX;
+	if (fileName.endsWith(".jsx")) return ts.ScriptKind.JSX;
+	if (fileName.endsWith(".js")) return ts.ScriptKind.JS;
+	return ts.ScriptKind.TS;
+}
+
+//#endregion
+//#region src/link.ts
+function resourceId(locator, kind) {
+	let id = locator.trim();
+	if (/^https?:\/\//.test(id)) {
+		const url = new URL(id);
+		id = kind === "machine" ? url.searchParams.get("machineId") ?? url.pathname.match(/\/machines?\/([^/]+)/)?.[1] ?? "" : url.pathname.match(/\/(?:projects?|editor)\/([^/]+)/)?.[1] ?? "";
+		id = decodeURIComponent(id);
+	}
+	if (!/^[\w-]+$/.test(id)) throw new Error(`Pass a ${kind} ID or a URL containing a ${kind} ID.`);
+	return id;
+}
+/** Association only: no definitions are uploaded, downloaded, or executed. */
+async function linkProject(options) {
+	if (options.projectId && options.create) throw new Error("Choose --project or --create, not both.");
+	if (Boolean(options.file) !== Boolean(options.machineId)) throw new Error("Machine association requires a file and --machine <id|url>.");
+	if (options.create && options.machineId) throw new Error("Link an existing machine to its existing project with --project; --create creates an empty project.");
+	if (options.visibility && !options.create) throw new Error("--visibility requires --create.");
+	if (options.name && !options.create) throw new Error("--name requires --create.");
+	const cwd = path.resolve(options.cwd ?? process.cwd());
+	const configPath = path.resolve(cwd, options.configPath ?? STATELY_CONFIG_FILE);
+	const existing = await readStatelyProjectConfig({
+		cwd,
+		configPath,
+		rewriteIfNeeded: false
+	}).catch((error) => {
+		if (error.code === "ENOENT") return void 0;
+		throw error;
+	});
+	if (existing?.rewriteStatus.reason === "multiple-legacy-sources") throw new Error("Update the legacy sources configuration manually before linking; no files were changed.");
+	const studioUrl = options.baseUrl ?? existing?.config.studioUrl ?? "https://stately.ai";
+	const requestedId = options.projectId ? resourceId(options.projectId, "project") : void 0;
+	const sameDeployment = !existing?.config.studioUrl || resolveApiBaseUrl(studioUrl) === resolveApiBaseUrl(existing.config.studioUrl);
+	if (existing?.config.projectId && (!sameDeployment || options.create || requestedId && requestedId !== existing.config.projectId) && !options.force) throw new Error(`Already linked to project ${existing.config.projectId}. Use --force to change the project association; existing machine IDs are retained.`);
+	const machineId = options.machineId ? resourceId(options.machineId, "machine") : void 0;
+	const filePath = options.file ? path.resolve(cwd, options.file) : void 0;
+	const source = filePath ? await fsPromises.readFile(filePath, "utf8") : void 0;
+	const machineIndex = options.machineIndex ?? 0;
+	if (filePath && source !== void 0) {
+		if (!/\.[cm]?[jt]sx?$/.test(filePath)) throw new Error("Machine association supports JavaScript and TypeScript source files.");
+		const attachments = findStatelyPragmaAttachments(source, filePath);
+		if (attachments.length > 1 && options.machineIndex === void 0) throw new Error("This file contains multiple machines. Select one with --machine-index (zero-based).");
+		const attachment = attachments[machineIndex];
+		if (!attachment || !Number.isInteger(machineIndex) || machineIndex < 0) throw new Error("No machine at the selected index.");
+		if (attachment.pragma?.id && attachment.pragma.id !== machineId && !options.force) throw new Error(`Machine already linked to ${attachment.pragma.id}. Use --force to replace its association.`);
+	} else if (options.machineIndex !== void 0) throw new Error("--machine-index requires a file and --machine.");
+	const client = options.client ?? createStatelyClient({
+		apiKey: options.apiKey,
+		baseUrl: resolveApiBaseUrl(studioUrl)
+	});
+	let project;
+	if (options.create) project = await client.projects.create({
+		name: options.name ?? path.basename(cwd),
+		visibility: options.visibility ?? "Private"
+	});
+	else {
+		const projectId = requestedId ?? existing?.config.projectId;
+		if (!projectId) throw new Error("Choose --project <id|url> or --create to connect this workspace.");
+		project = await client.projects.get(projectId);
+	}
+	if (machineId) {
+		if (!project.machines.some((machine) => machine.machineId === machineId)) throw new Error(`Machine ${machineId} is not in project ${project.projectId}. No files were changed.`);
+		await client.machines.get(machineId);
+	}
+	if (filePath && await fsPromises.readFile(filePath, "utf8") !== source) throw new Error("Source changed while linking. Retry; no files were changed.");
+	const config = {
+		...existing?.config ?? createStatelyProjectConfig({}),
+		projectId: project.projectId,
+		studioUrl
+	};
+	const writes = [];
+	const stage = async (destination, write) => {
+		const suffix = randomUUID();
+		const entry = {
+			path: destination,
+			staged: `${destination}.${suffix}.tmp`,
+			backup: `${destination}.${suffix}.bak`,
+			existed: false,
+			committed: false
+		};
+		writes.push(entry);
+		try {
+			await fsPromises.copyFile(destination, entry.backup);
+			entry.existed = true;
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		await write(entry.staged);
+		if (entry.existed) await fsPromises.chmod(entry.staged, (await fsPromises.stat(destination)).mode);
+	};
+	let rollbackFailed = false;
+	try {
+		await stage(configPath, (temporary) => writeStatelyProjectConfig(temporary, config));
+		if (filePath && source !== void 0 && machineId) {
+			const updated = upsertStatelyPragma(source, machineId, {
+				fileName: filePath,
+				machineIndex
+			});
+			if (updated !== source) await stage(filePath, (temporary) => fsPromises.writeFile(temporary, updated, "utf8"));
+		}
+		if (filePath && await fsPromises.readFile(filePath, "utf8") !== source) throw new Error("Source changed while linking. Retry; no files were changed.");
+		for (const entry of writes) {
+			await fsPromises.rename(entry.staged, entry.path);
+			entry.committed = true;
+		}
+	} catch (error) {
+		const rollbackErrors = [];
+		for (const entry of [...writes].reverse()) {
+			if (!entry.committed) continue;
+			try {
+				if (entry.existed) await fsPromises.rename(entry.backup, entry.path);
+				else await fsPromises.unlink(entry.path);
+			} catch (rollbackError) {
+				rollbackFailed = true;
+				rollbackErrors.push(rollbackError);
+			}
+		}
+		if (rollbackFailed) throw new AggregateError([error, ...rollbackErrors], "Link failed and could not restore every file. Original files are retained in .bak files beside their destinations.");
+		throw error;
+	} finally {
+		await Promise.all(writes.flatMap((entry) => rollbackFailed ? [entry.staged] : [entry.staged, entry.backup]).map((temporary) => fsPromises.rm(temporary, { force: true })));
+	}
+	return {
+		project,
+		config,
+		configPath,
+		machineId,
+		filePath
+	};
+}
+
 //#endregion
 //#region ../editor-sync/dist/fs-Dw5c-Wnp.mjs
 function comparePosition(left, right) {
@@ -7418,7 +7649,7 @@ function buildMeta(meta, color, showStatelyMeta = true) {
 	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 && showStatelyMeta) result["@statelyai.color"] = color;
+	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) */
@@ -10355,7 +10586,7 @@ function graphToXStateTSResult(inputGraph, options = {}) {
 	if (xstateVersion === 6) stripStateSchemas(machineConfig);
 	let machineExpr;
 	if (hasSetup) {
-		const setupObj = buildSetupObject(schemas, impls, {
+		const setupObj = buildSetupObject(graph, schemas, impls, {
 			includeTypeSyntax: supportsTypeSyntax,
 			xstateVersion,
 			xstateV6SchemaFormat
@@ -11155,7 +11386,7 @@ function getActorSourceImports(graph) {
 	}
 	return imports;
 }
-function buildSetupObject(schemas, impls, options) {
+function buildSetupObject(graph, schemas, impls, options) {
 	const setup = {};
 	if (options.xstateVersion === 6) {
 		const schemasBlock = buildV6SchemasBlock(schemas, options);
@@ -11165,7 +11396,10 @@ function buildSetupObject(schemas, impls, options) {
 		if (types) setup.types = types;
 	}
 	if (impls?.actions.length) setup.actions = buildActionsBlock(impls.actions, options);
-	if (impls?.guards.length) setup.guards = buildGuardsBlock(impls.guards, options);
+	if (impls?.guards.length) setup.guards = buildGuardsBlock(impls.guards, {
+		...options,
+		argsTypes: options.xstateVersion === 6 && options.includeTypeSyntax ? new Map(impls.guards.map((guard) => [guard.name, getV6GuardArgsType(graph, guard.name)])) : void 0
+	});
 	if (impls?.actors.length) setup.actors = buildActorsBlock(impls.actors, {
 		...options,
 		xstateVersion: options.xstateVersion
@@ -11266,18 +11500,68 @@ function buildActionsBlock(actions, options) {
 	} else block[implementation.name] = raw(options.xstateVersion === 6 ? `function () {\n  // TODO: implement ${implementation.name}\n}` : `function ({ context, event }) {\n  // TODO: implement ${implementation.name}\n}`);
 	return block;
 }
+/**
+* XState v6 types `setup({ guards })` entries as `(...params: any[]) => boolean`
+* and injects nothing: a named guard receives exactly what its caller passes.
+* Generated transition functions call `guards[name]({ context, event }, params)`
+* (as does `createMachineFromConfig`), so that is the argument type to declare.
+*/
+function getV6GuardArgsType(graph, guardName) {
+	const schemas = graph.data.schemas;
+	const rootContextType = contextSchemaToTSType(schemas?.context);
+	const contexts = graph.edges.filter((edge) => !edge.data.temp && edge.data.guard?.type === guardName).map((edge) => {
+		const types = [];
+		let node = graph.nodes.find((candidate) => candidate.id === edge.sourceId);
+		while (node) {
+			const type = contextSchemaToTSType(node.data.schemas?.context);
+			if (type) types.unshift(type);
+			node = graph.nodes.find((candidate) => candidate.id === node?.parentId);
+		}
+		if (rootContextType) types.unshift(rootContextType);
+		return types.length ? types.join(" & ") : void 0;
+	});
+	const contextType = contexts.some(Boolean) ? [...new Set(contexts.map((type) => type ?? "any"))].join(" | ") : rootContextType;
+	const eventSchemas = {
+		...schemas?.events,
+		...schemas?.internalEvents
+	};
+	const declaredEventType = eventsSchemaToTSType(eventSchemas);
+	if (!contextType && !declaredEventType) return void 0;
+	const eventType = declaredEventType ? `${declaredEventType} | Exclude<import('xstate').ReservedMachineEvent, { type: ${Object.keys(eventSchemas).map((type) => serializeJS(type)).join(" | ")} }>` : "any";
+	return `{ context: ${contextType ?? "any"}; event: ${eventType} }`;
+}
+/**
+* True when an authored guard expression destructures the generated
+* `{ context, event }` argument without annotating it, so contextual typing
+* can supply the types without contradicting an authored signature.
+*/
+function usesGeneratedGuardArgs(code) {
+	const expression = parseSingleExpression(code)?.expression;
+	if (!expression || !ts.isArrowFunction(expression) && !ts.isFunctionExpression(expression)) return false;
+	const [first] = expression.parameters;
+	if (!first || first.type || !ts.isObjectBindingPattern(first.name)) return false;
+	return first.name.elements.every((element) => {
+		const property = element.propertyName ?? element.name;
+		return !element.dotDotDotToken && ts.isIdentifier(property) && (property.text === "context" || property.text === "event");
+	});
+}
 function buildGuardsBlock(guards, options) {
 	const block = {};
-	for (const guard of guards) if (guard.code?.body) {
-		const inlineExpression = getInlineExpression$1(guard.code.body);
-		if (inlineExpression) {
-			block[guard.name] = raw(inlineExpression, guard.code);
-			continue;
-		}
-		const params = hasSchemaProperties(guard.paramsSchema) ? options.includeTypeSyntax ? `, params: ${jsonSchemaToTSType(guard.paramsSchema)}` : ", params" : "";
-		const body = dedent(guard.code.body);
-		block[guard.name] = rawWithSourceSlice(`function ({ context, event }${params ? params : ""}) {\n  `, body, "\n}", guard.code);
-	} else block[guard.name] = raw(`function ({ context, event }) {\n  // TODO: implement ${guard.name}\n  return false;\n}`);
+	for (const guard of guards) {
+		const argsType = options.argsTypes?.get(guard.name);
+		const argsAnnotation = argsType ? `: ${argsType}` : "";
+		const paramsType = hasSchemaProperties(guard.paramsSchema) ? jsonSchemaToTSType(guard.paramsSchema) : void 0;
+		if (guard.code?.body) {
+			const inlineExpression = getInlineExpression$1(guard.code.body);
+			if (inlineExpression) {
+				block[guard.name] = argsType && usesGeneratedGuardArgs(inlineExpression) ? rawWithSourceSlice("(", inlineExpression, `) satisfies (args: ${argsType}, params: ${paramsType ?? "any"}) => boolean`, guard.code) : raw(inlineExpression, guard.code);
+				continue;
+			}
+			const params = paramsType ? options.includeTypeSyntax ? `, params: ${paramsType}` : ", params" : "";
+			const body = dedent(guard.code.body);
+			block[guard.name] = rawWithSourceSlice(`function ({ context, event }${argsAnnotation}${params}) {\n  `, body, "\n}", guard.code);
+		} else block[guard.name] = raw(`function ({ context, event }${argsAnnotation}) {\n  // TODO: implement ${guard.name}\n  return false;\n}`);
+	}
 	return block;
 }
 function buildActorsBlock(actors, options) {
@@ -13528,7 +13812,7 @@ function modify(text, path, value, options) {
 //#region ../editor-sync/dist/adapters-9XXzVfbF.mjs
 const sourceFileUris = /* @__PURE__ */ new WeakMap();
 function collectXStateSourceLocations(sourceText, document, options = {}) {
-	const sourceFile = ts$1.createSourceFile(document.fileName, sourceText, ts$1.ScriptTarget.Latest, true, getScriptKind$2$1(document.fileName));
+	const sourceFile = ts$1.createSourceFile(document.fileName, sourceText, ts$1.ScriptTarget.Latest, true, getScriptKind$2(document.fileName));
 	const uri = document.uri?.toString() ?? document.fileName;
 	sourceFileUris.set(sourceFile, uri);
 	const bindings = collectBindings(sourceFile, uri, document.fileName, options);
@@ -13590,7 +13874,7 @@ function machineFactoryPackage(sourceFile, document, machineIndex = 0, resolver)
 		let target = modules.get(snapshot.uri);
 		if (!target) {
 			target = {
-				file: ts$1.createSourceFile(snapshot.fileName, snapshot.text, ts$1.ScriptTarget.Latest, true, getScriptKind$2$1(snapshot.fileName)),
+				file: ts$1.createSourceFile(snapshot.fileName, snapshot.text, ts$1.ScriptTarget.Latest, true, getScriptKind$2(snapshot.fileName)),
 				document: snapshot
 			};
 			modules.set(snapshot.uri, target);
@@ -13663,7 +13947,7 @@ function machineFactoryPackage(sourceFile, document, machineIndex = 0, resolver)
 	let index = 0;
 	const visit = (node) => {
 		if (factory) return;
-		if (ts$1.isCallExpression(node) && isCreateMachineExpression$1$1(node.expression)) {
+		if (ts$1.isCallExpression(node) && isCreateMachineExpression$1(node.expression)) {
 			if (index++ === machineIndex) factory = node;
 			return;
 		}
@@ -13744,7 +14028,7 @@ function parseRangePart(value) {
 }
 function collectImportedXStateTransitionSources(sourceText, document, options = {}) {
 	if (!options.resolver) return [];
-	const sourceFile = ts$1.createSourceFile(document.fileName, sourceText, ts$1.ScriptTarget.Latest, true, getScriptKind$2$1(document.fileName));
+	const sourceFile = ts$1.createSourceFile(document.fileName, sourceText, ts$1.ScriptTarget.Latest, true, getScriptKind$2(document.fileName));
 	const uri = document.uri?.toString() ?? document.fileName;
 	sourceFileUris.set(sourceFile, uri);
 	const bindings = collectBindings(sourceFile, uri, document.fileName, options);
@@ -13835,7 +14119,7 @@ function resolveExportedStaticValue(document, exportName, resolver, visited) {
 	if (visited.has(visitKey)) return null;
 	visited.add(visitKey);
 	try {
-		const sourceFile = ts$1.createSourceFile(document.fileName, document.text, ts$1.ScriptTarget.Latest, true, getScriptKind$2$1(document.fileName));
+		const sourceFile = ts$1.createSourceFile(document.fileName, document.text, ts$1.ScriptTarget.Latest, true, getScriptKind$2(document.fileName));
 		sourceFileUris.set(sourceFile, document.uri);
 		const localBindings = collectStaticValueBindings(sourceFile);
 		const localBinding = localBindings.get(exportName);
@@ -13973,7 +14257,7 @@ function addImportedBindings(bindings, sourceFile, uri, fileName, options, cache
 			uri
 		}, statement.moduleSpecifier.text);
 		if (!importedDocument) continue;
-		const importedSourceFile = ts$1.createSourceFile(importedDocument.fileName, importedDocument.text, ts$1.ScriptTarget.Latest, true, getScriptKind$2$1(importedDocument.fileName));
+		const importedSourceFile = ts$1.createSourceFile(importedDocument.fileName, importedDocument.text, ts$1.ScriptTarget.Latest, true, getScriptKind$2(importedDocument.fileName));
 		sourceFileUris.set(importedSourceFile, importedDocument.uri);
 		const importedBindings = collectBindings(importedSourceFile, importedDocument.uri, importedDocument.fileName, options, cache);
 		for (const element of namedBindings.elements) {
@@ -14044,7 +14328,7 @@ function findMachineConfigObjectLiteral$1(sourceFile, bindings, machineIndex = 0
 	let currentMachineIndex = 0;
 	const visit = (node) => {
 		if (found) return;
-		if (ts$1.isCallExpression(node) && isCreateMachineExpression$1$1(node.expression)) {
+		if (ts$1.isCallExpression(node) && isCreateMachineExpression$1(node.expression)) {
 			const isSelectedMachine = currentMachineIndex === machineIndex;
 			currentMachineIndex += 1;
 			if (!isSelectedMachine) return;
@@ -14312,7 +14596,7 @@ function getEnumMemberName(name) {
 	if (ts$1.isIdentifier(name) || ts$1.isStringLiteral(name) || ts$1.isNumericLiteral(name)) return name.text;
 	return null;
 }
-function isCreateMachineExpression$1$1(expression) {
+function isCreateMachineExpression$1(expression) {
 	const isMachineFactoryName = (name) => name === "createMachine" || name === "createMachineFromConfig";
 	return ts$1.isIdentifier(expression) && isMachineFactoryName(expression.text) || ts$1.isPropertyAccessExpression(expression) && isMachineFactoryName(expression.name.text);
 }
@@ -14348,7 +14632,7 @@ function toSourceRange$1(sourceFile, node) {
 		endChar: end.character
 	};
 }
-function getScriptKind$2$1(fileName) {
+function getScriptKind$2(fileName) {
 	if (fileName.endsWith(".tsx")) return ts$1.ScriptKind.TSX;
 	if (fileName.endsWith(".jsx")) return ts$1.ScriptKind.JSX;
 	if (fileName.endsWith(".js")) return ts$1.ScriptKind.JS;
@@ -14440,7 +14724,7 @@ function selectMachineInModule(source, machineIndex, factory, expression) {
 	let factoryAlias = "__stately_sync_factory";
 	while (source.includes(factoryAlias)) factoryAlias += "_";
 	const visit = (node) => {
-		if (ts$1.isCallExpression(node) && isCreateMachineExpression$1$1(node.expression)) {
+		if (ts$1.isCallExpression(node) && isCreateMachineExpression$1(node.expression)) {
 			if (index++ === machineIndex) replacements.push({
 				start: node.getStart(file),
 				end: node.getEnd(),
@@ -21030,7 +21314,7 @@ function sourceLocationUris(sourceLocations) {
 
 //#endregion
 //#region src/version.ts
-const CLI_VERSION = "0.13.0";
+const CLI_VERSION = "0.14.1";
 
 //#endregion
 //#region src/cliHost.ts
@@ -21482,7 +21766,7 @@ async function openSourceDocument(fileName) {
 	};
 }
 function collectRelativeImportSpecifiers(text, fileName) {
-	const sourceFile = ts$1.createSourceFile(fileName, text, ts$1.ScriptTarget.Latest, true, getScriptKind$2(fileName));
+	const sourceFile = ts$1.createSourceFile(fileName, text, ts$1.ScriptTarget.Latest, true, getScriptKind$1(fileName));
 	const specifiers = [];
 	for (const statement of sourceFile.statements) {
 		const moduleSpecifier = ts$1.isImportDeclaration(statement) || ts$1.isExportDeclaration(statement) ? statement.moduleSpecifier : void 0;
@@ -21509,7 +21793,7 @@ function resolveRelativeImportCandidates(fromFileName, specifier) {
 		...importExtensions.map((extension) => path$1.join(basePath, `index${extension}`))
 	];
 }
-function getScriptKind$2(fileName) {
+function getScriptKind$1(fileName) {
 	if (fileName.endsWith(".tsx")) return ts$1.ScriptKind.TSX;
 	if (fileName.endsWith(".jsx")) return ts$1.ScriptKind.JSX;
 	if (/\.(?:c|m)?js$/.test(fileName)) return ts$1.ScriptKind.JS;
@@ -22031,105 +22315,6 @@ function describeCredentialBackend(backend, location) {
 	}
 }
 
-//#endregion
-//#region ../editor-sync/dist/statelyPragma-D46lczJR.mjs
-function findStatelyPragmaAttachments(sourceText, fileName = "machine.ts") {
-	const sourceFile = ts.createSourceFile(fileName, sourceText, ts.ScriptTarget.Latest, true, getScriptKind$1(fileName));
-	const attachments = [];
-	const visit = (node) => {
-		if (ts.isCallExpression(node) && isCreateMachineExpression$1(node.expression)) {
-			const attachNode = findAttachNode(node);
-			if (attachNode) attachments.push({
-				machineStart: getMachineExpressionStart(node.expression, sourceFile),
-				attachStart: attachNode.getStart(sourceFile),
-				pragma: findAttachedStatelyPragma(sourceText, attachNode)
-			});
-		}
-		ts.forEachChild(node, visit);
-	};
-	visit(sourceFile);
-	return attachments;
-}
-function getStatelyPragma(sourceText, fileName = "machine.ts", machineIndex = 0) {
-	return findStatelyPragmaAttachments(sourceText, fileName)[machineIndex]?.pragma;
-}
-function upsertStatelyPragma(sourceText, id, options = {}) {
-	const attachment = findStatelyPragmaAttachments(sourceText, options.fileName ?? "machine.ts")[options.machineIndex ?? 0];
-	if (!attachment) return sourceText;
-	const lineEnding = options.lineEnding ?? detectLineEnding(sourceText);
-	const canonicalComment = `// @statelyai id=${id}`;
-	if (attachment.pragma) return sourceText.slice(0, attachment.pragma.start) + canonicalComment + sourceText.slice(attachment.pragma.end);
-	const insertText = `${getIndentationAtOffset(sourceText, attachment.attachStart)}${canonicalComment}${lineEnding}`;
-	return sourceText.slice(0, attachment.attachStart) + insertText + sourceText.slice(attachment.attachStart);
-}
-function findAttachedStatelyPragma(sourceText, node) {
-	const comments = ts.getLeadingCommentRanges(sourceText, node.getFullStart()) ?? [];
-	for (let index = comments.length - 1; index >= 0; index -= 1) {
-		const comment = comments[index];
-		const parsed = parseStatelyPragma(sourceText, comment.pos, comment.end);
-		if (parsed) return parsed;
-	}
-}
-function parseStatelyPragma(sourceText, start, end) {
-	const match = normalizeCommentContent(sourceText.slice(start, end)).match(/^@statelyai(?:\s+(.*))?$/s);
-	if (!match) return;
-	const fields = parseFields(match[1] ?? "");
-	return {
-		tag: "@statelyai",
-		id: fields.id,
-		fields,
-		start,
-		end
-	};
-}
-function normalizeCommentContent(rawComment) {
-	if (rawComment.startsWith("//")) return rawComment.slice(2).trim();
-	if (rawComment.startsWith("/*")) return rawComment.slice(2, rawComment.endsWith("*/") ? -2 : void 0).split(/\r?\n/).map((line) => line.replace(/^\s*\*\s?/, "")).join(" ").trim();
-	return rawComment.trim();
-}
-function parseFields(input) {
-	const fields = {};
-	for (const token of input.split(/\s+/)) {
-		if (!token) continue;
-		const equalsIndex = token.indexOf("=");
-		if (equalsIndex <= 0) continue;
-		const key = token.slice(0, equalsIndex);
-		const value = token.slice(equalsIndex + 1);
-		if (!key || !value) continue;
-		fields[key] = value;
-	}
-	return fields;
-}
-function findAttachNode(node) {
-	let current = node;
-	while (current?.parent) {
-		if (ts.isVariableStatement(current.parent) || ts.isExpressionStatement(current.parent) || ts.isExportAssignment(current.parent)) return current.parent;
-		current = current.parent;
-	}
-	return current;
-}
-function isCreateMachineExpression$1(expression) {
-	const isMachineFactoryName = (name) => name === "createMachine" || name === "createMachineFromConfig";
-	return ts.isIdentifier(expression) && isMachineFactoryName(expression.text) || ts.isPropertyAccessExpression(expression) && isMachineFactoryName(expression.name.text);
-}
-function getMachineExpressionStart(expression, sourceFile) {
-	if (ts.isPropertyAccessExpression(expression)) return expression.name.getStart(sourceFile);
-	return expression.getStart(sourceFile);
-}
-function getIndentationAtOffset(sourceText, offset) {
-	const lineStart = sourceText.lastIndexOf("\n", Math.max(0, offset - 1)) + 1;
-	return sourceText.slice(lineStart, offset).match(/^[ \t]*/)?.[0] ?? "";
-}
-function detectLineEnding(sourceText) {
-	return sourceText.includes("\r\n") ? "\r\n" : "\n";
-}
-function getScriptKind$1(fileName) {
-	if (fileName.endsWith(".tsx")) return ts.ScriptKind.TSX;
-	if (fileName.endsWith(".jsx")) return ts.ScriptKind.JSX;
-	if (fileName.endsWith(".js")) return ts.ScriptKind.JS;
-	return ts.ScriptKind.TS;
-}
-
 //#endregion
 //#region ../../node_modules/.pnpm/@statelyai+graph@2.1.0_@statelyai+layout@0.4.3_cytoscape@3.34.0_d3-force@3.0.0_d3-hiera_2afdfa88fae2fa10712f99651d0f58d6/node_modules/@statelyai/graph/dist/index.mjs
 const LAYOUT_KEYS = {
@@ -22582,7 +22767,7 @@ function fromXStateConfig(config) {
 	};
 }
 async function pushLocalMachineLinks(options) {
-	const client = options.client ?? createStatelyClient({
+	const client = options.client ?? createStatelyClient$1({
 		apiKey: options.apiKey,
 		baseUrl: options.baseUrl,
 		fetch: options.fetch
@@ -22679,7 +22864,7 @@ async function resolveLocalFile(locator, options, machineIndex = 0) {
 		let config = localExtraction.machines[0]?.config;
 		const extractionIssue = localExtraction.error;
 		if (!config) {
-			const extracted = await (options.client ?? createStatelyClient({
+			const extracted = await (options.client ?? createStatelyClient$1({
 				apiKey: options.apiKey,
 				baseUrl: options.baseUrl,
 				fetch: options.fetch
@@ -22751,7 +22936,7 @@ function inferXStateTargetLanguage(targetPath) {
 	return /\.(?:c|m)?jsx?$/i.test(targetPath) ? "javascript" : "typescript";
 }
 async function resolveRemoteMachine(machineId, baseUrl, kind, locator, options) {
-	const digraph = (await (options.client ?? createStatelyClient({
+	const digraph = (await (options.client ?? createStatelyClient$1({
 		apiKey: options.apiKey,
 		baseUrl,
 		fetch: options.fetch
@@ -23523,7 +23708,7 @@ async function initProject(options) {
 			reusedExistingConfig: true
 		};
 		if (existingConfig.config.projectId) {
-			const client = options.client ?? createStatelyClient$1({
+			const client = options.client ?? createStatelyClient({
 				apiKey: options.apiKey,
 				baseUrl: apiBaseUrl
 			});
@@ -23544,7 +23729,7 @@ async function initProject(options) {
 			reusedExistingConfig: false
 		};
 	}
-	const client = options.client ?? createStatelyClient$1({
+	const client = options.client ?? createStatelyClient({
 		apiKey: options.apiKey,
 		baseUrl: apiBaseUrl
 	});
@@ -23670,9 +23855,9 @@ async function resolveConfiguredProject(options) {
 		configPath: options.configPath,
 		rewriteIfNeeded: options.rewriteIfNeeded ?? true
 	});
-	if (!config.projectId) throw new Error("This is a local-only project. Run `statelyai init` to connect it to Stately Studio.");
+	if (!config.projectId) throw new Error("This is a local-only project. Run `statelyai link` to connect it to Stately Studio.");
 	return {
-		client: options.client ?? createStatelyClient$1({
+		client: options.client ?? createStatelyClient({
 			apiKey: options.apiKey,
 			baseUrl: resolveApiBaseUrl(options.baseUrl ?? config.studioUrl)
 		}),
@@ -23779,7 +23964,7 @@ async function resolveProjectStatus(options = {}) {
 		};
 	}
 	const apiKey = options.apiKey ?? (options.client ? void 0 : (await resolveApiKey()).apiKey);
-	const client = options.client ?? createStatelyClient$1({
+	const client = options.client ?? createStatelyClient({
 		apiKey,
 		baseUrl: resolveApiBaseUrl(studioUrl)
 	});
@@ -24293,6 +24478,93 @@ async function discoverMachinesInFile(filePath) {
 		relativePath: path.basename(filePath)
 	}];
 }
+var LinkCommand = class LinkCommand extends Command {
+	static summary = "Connect a workspace or source machine to Stately Studio without syncing definitions.";
+	static args = { file: Args.string({ description: "Source file to associate with --machine" }) };
+	static flags = {
+		help: Flags.help({ char: "h" }),
+		project: Flags.string({
+			description: "Existing Studio project ID or URL",
+			exclusive: ["create"]
+		}),
+		create: Flags.boolean({
+			description: "Create a new Studio project",
+			default: false
+		}),
+		name: Flags.string({
+			description: "Name for --create",
+			dependsOn: ["create"]
+		}),
+		visibility: Flags.string({
+			description: "Visibility for --create",
+			options: [
+				"Private",
+				"Public",
+				"Unlisted"
+			]
+		}),
+		machine: Flags.string({ description: "Existing remote machine ID or URL; requires a source file" }),
+		"machine-index": Flags.integer({
+			description: "Zero-based machine index in a multi-machine source file",
+			min: 0
+		}),
+		"base-url": Flags.string({ description: "Studio deployment origin" }),
+		config: Flags.string({ description: "Path to statelyai.json" }),
+		force: Flags.boolean({
+			description: "Replace an existing project or machine association",
+			default: false
+		})
+	};
+	async run() {
+		const { args, flags } = await this.parse(LinkCommand);
+		let projectId = flags.project;
+		let create = flags.create;
+		const credential = await resolveApiKey();
+		const config = await readStatelyProjectConfig({ configPath: flags.config }).catch((error) => {
+			if (error.code === "ENOENT") return void 0;
+			throw error;
+		});
+		const baseUrl = flags["base-url"] ?? config?.config.studioUrl ?? getResolvedStudioUrl();
+		if (!projectId && !create && !config?.config.projectId && process.stdin.isTTY && process.stdout.isTTY) {
+			const projects = await createStatelyClient({
+				apiKey: credential.apiKey,
+				baseUrl: resolveApiBaseUrl(baseUrl)
+			}).projects.list();
+			projects.forEach((project, index) => this.log(`${index + 1}. ${project.name} (${project.projectId})`));
+			this.log("0. Create a new Studio project");
+			const rl = createInterface({
+				input: process.stdin,
+				output: process.stdout
+			});
+			try {
+				const answer = (await rl.question("Choose a project number: ")).trim();
+				if (!/^\d+$/.test(answer)) this.error("Choose a project number, or pass --project <id> or --create.");
+				const choice = Number(answer);
+				if (choice === 0) create = true;
+				else if (projects[choice - 1]) projectId = projects[choice - 1].projectId;
+				else this.error("No project at that number.");
+			} finally {
+				rl.close();
+			}
+		}
+		const result = await linkProject({
+			projectId,
+			create,
+			apiKey: credential.apiKey,
+			baseUrl,
+			configPath: flags.config,
+			name: flags.name,
+			visibility: flags.visibility,
+			force: flags.force,
+			file: args.file,
+			machineId: flags.machine,
+			machineIndex: flags["machine-index"]
+		});
+		this.log(`Connected to Studio project ${result.project.name} (${result.project.projectId}).`);
+		if (result.machineId) this.log(`Associated ${args.file} with machine ${result.machineId}.`);
+		this.log("No machine definitions uploaded or downloaded. Use push or pull to sync.");
+	}
+};
 var InitCommand = class InitCommand extends Command {
 	static enableJsonFlag = false;
 	static summary = "Create a local or Studio-connected statelyai.json.";
@@ -24343,6 +24615,7 @@ var InitCommand = class InitCommand extends Command {
 			if (resolvedApiKey.source === "missing" && error instanceof StudioApiError && (error.status === 401 || error.status === 403)) this.error("Not logged in. Run `npx statelyai login` and retry. To initialize without an account, run `npx statelyai init --local` (add `--force` to replace an existing config).");
 			throw error;
 		}
+		this.log("For separate local setup and Studio linking, use `statelyai init --local --scan`, then `statelyai link`.");
 		const initMessage = result.project ? (() => {
 			const projectEditorUrl = buildProjectEditorUrl(result.config.studioUrl, result.project.projectId);
 			return result.reusedExistingConfig ? `Using existing statelyai.json at ${result.configPath} for project ${result.project.projectId}.\nEditor: ${projectEditorUrl}` : `Initialized project ${result.project.projectId} and wrote ${result.configPath}.\nEditor: ${projectEditorUrl}`;
@@ -24510,6 +24783,7 @@ const COMMANDS = {
 	scan: ScanCommand,
 	status: StatusCommand,
 	init: InitCommand,
+	link: LinkCommand,
 	login: LoginCommand,
 	logout: LogoutCommand,
 	whoami: WhoamiCommand,
@@ -24539,4 +24813,4 @@ function isDirectExecution() {
 if (isDirectExecution()) run$1();
 
 //#endregion
-export { briefReport as A, run$1 as C, verifyProject as D, resolveVerificationRequest as E, pendingReport as M, readGraphFile as N, formatVerificationJUnit as O, verifyReport as P, resolveProjectStatus as S, scanProjectSources as T, isFileGitDirty as _, discoverMachinesInSource as a, resolveCredentialStatus as b, formatDiscoveredMachines as c, formatProjectStatus as d, formatStoredCredentialSource as f, initProject as g, inferInitProjectName as h, discoverLinkedPullTargets as i, changesReport as j, createStatelyProjectConfig as k, formatMissingNewMachineDirMessage as l, getEnvCredential as m, buildOAuthLoginStart as n, discoverOAuthLogin as o, getEnvApiKey as p, classifyPushCandidates as r, discoverRemoteProjectMachineTargets as s, COMMANDS as t, formatPlanSummary as u, resolveApiKey as v, scanProjectMachines as w, resolveOpenRootDir as x, resolveConfiguredPullTargets as y };
+export { formatVerificationJUnit as A, run$1 as C, resourceId as D, linkProject as E, readGraphFile as F, verifyReport as I, briefReport as M, changesReport as N, resolveVerificationRequest as O, pendingReport as P, resolveProjectStatus as S, scanProjectSources as T, isFileGitDirty as _, discoverMachinesInSource as a, resolveCredentialStatus as b, formatDiscoveredMachines as c, formatProjectStatus as d, formatStoredCredentialSource as f, initProject as g, inferInitProjectName as h, discoverLinkedPullTargets as i, createStatelyProjectConfig as j, verifyProject as k, formatMissingNewMachineDirMessage as l, getEnvCredential as m, buildOAuthLoginStart as n, discoverOAuthLogin as o, getEnvApiKey as p, classifyPushCandidates as r, discoverRemoteProjectMachineTargets as s, COMMANDS as t, formatPlanSummary as u, resolveApiKey as v, scanProjectMachines as w, resolveOpenRootDir as x, resolveConfiguredPullTargets as y };

package/dist/index.d.mts

@@ -1,8 +1,8 @@
 import { Command } from "@oclif/core";
 import { XGraph } from "@statelyai/mcp/loop";
 import { z } from "zod";
+import { ConnectedRepo, CreateProjectInput, LegacyProjectVisibility, OAuthAuthorizationServerMetadata, OAuthProtectedResourceMetadata, ProjectData, ProjectMachineSummary, ProjectVisibility, StudioClient } from "@statelyai/sdk";
 import { StatelyGraph } from "@statelyai/sdk/graph";
-import { ConnectedRepo, CreateProjectInput, OAuthAuthorizationServerMetadata, OAuthProtectedResourceMetadata, ProjectData, ProjectMachineSummary, StudioClient } from "@statelyai/sdk";
 import * as _oclif_core_interfaces0 from "@oclif/core/interfaces";
 
 //#region src/verifyCommand.d.ts
@@ -27,6 +27,43 @@ declare class VerifyCommand extends Command {
   run(): Promise<void>;
 }
 //#endregion
+//#region src/link.d.ts
+interface LinkProjectOptions {
+  cwd?: string;
+  configPath?: string;
+  apiKey?: string;
+  baseUrl?: string;
+  client?: StudioClient;
+  projectId?: string;
+  create?: boolean;
+  name?: string;
+  visibility?: ProjectVisibility | LegacyProjectVisibility;
+  force?: boolean;
+  file?: string;
+  machineId?: string;
+  machineIndex?: number;
+}
+declare function resourceId(locator: string, kind: 'project' | 'machine'): string;
+/** Association only: no definitions are uploaded, downloaded, or executed. */
+declare function linkProject(options: LinkProjectOptions): Promise<{
+  project: ProjectData;
+  config: {
+    projectId: string;
+    studioUrl: string;
+    $schema: string;
+    version: string;
+    defaultXStateVersion: number;
+    sourceUpdateStrategy?: "preserve" | "rewrite";
+    include: string[];
+    exclude?: string[];
+    newMachinesDir?: string;
+    storage?: "local" | "hosted";
+  };
+  configPath: string;
+  machineId: string | undefined;
+  filePath: string | undefined;
+}>;
+//#endregion
 //#region src/loopCommands.d.ts
 /**
  * Offline loop commands over XGraph JSON files and the repository's
@@ -609,6 +646,25 @@ declare class OpenCommand extends Command {
   run(): Promise<void>;
 }
 declare function resolveOpenRootDir(cwd: string, fileArg?: string): string;
+declare class LinkCommand extends Command {
+  static summary: string;
+  static args: {
+    file: _oclif_core_interfaces0.Arg<string | undefined, Record<string, unknown>>;
+  };
+  static flags: {
+    help: _oclif_core_interfaces0.BooleanFlag<void>;
+    project: _oclif_core_interfaces0.OptionFlag<string | undefined, _oclif_core_interfaces0.CustomOptions>;
+    create: _oclif_core_interfaces0.BooleanFlag<boolean>;
+    name: _oclif_core_interfaces0.OptionFlag<string | undefined, _oclif_core_interfaces0.CustomOptions>;
+    visibility: _oclif_core_interfaces0.OptionFlag<string | undefined, _oclif_core_interfaces0.CustomOptions>;
+    machine: _oclif_core_interfaces0.OptionFlag<string | undefined, _oclif_core_interfaces0.CustomOptions>;
+    'machine-index': _oclif_core_interfaces0.OptionFlag<number | undefined, _oclif_core_interfaces0.CustomOptions>;
+    'base-url': _oclif_core_interfaces0.OptionFlag<string | undefined, _oclif_core_interfaces0.CustomOptions>;
+    config: _oclif_core_interfaces0.OptionFlag<string | undefined, _oclif_core_interfaces0.CustomOptions>;
+    force: _oclif_core_interfaces0.BooleanFlag<boolean>;
+  };
+  run(): Promise<void>;
+}
 declare class InitCommand extends Command {
   static enableJsonFlag: boolean;
   static summary: string;
@@ -689,6 +745,7 @@ declare const COMMANDS: {
   scan: typeof ScanCommand;
   status: typeof StatusCommand;
   init: typeof InitCommand;
+  link: typeof LinkCommand;
   login: typeof LoginCommand;
   logout: typeof LogoutCommand;
   whoami: typeof WhoamiCommand;
@@ -1616,4 +1673,4 @@ declare function verifyProject(options?: VerifyProjectOptions): Promise<{
 /** One case per recorded path/probe. Unattributed divergences remain separate cases. */
 declare function formatVerificationJUnit(report: VerificationRunReport): string;
 //#endregion
-export { ApiKeyResolution, COMMANDS, CredentialStatus, DiscoveredMachine, InitProjectOptions, InitProjectResult, LinkedPullTarget, OAuthLoginDiscovery, ProjectMachineStatus, ProjectStatusMachine, ProjectStatusResult, PushCandidateClassification, RemoteProjectMachineTarget, ResolveApiKeyOptions, ResolvedConfiguredPullTargets, ScanProjectSourcesOptions, type VerificationExecutor, type VerificationRequest, type VerificationRunReport, type VerifyProjectOptions, briefReport, buildOAuthLoginStart, changesReport, classifyPushCandidates, createStatelyProjectConfig, discoverLinkedPullTargets, discoverMachinesInSource, discoverOAuthLogin, discoverRemoteProjectMachineTargets, formatDiscoveredMachines, formatMissingNewMachineDirMessage, formatPlanSummary, formatProjectStatus, formatStoredCredentialSource, formatVerificationJUnit, getEnvApiKey, getEnvCredential, inferInitProjectName, initProject, isFileGitDirty, pendingReport, readGraphFile, resolveApiKey, resolveConfiguredPullTargets, resolveCredentialStatus, resolveOpenRootDir, resolveProjectStatus, resolveVerificationRequest, run, scanProjectMachines, scanProjectSources, verifyProject, verifyReport };
+export { ApiKeyResolution, COMMANDS, CredentialStatus, DiscoveredMachine, InitProjectOptions, InitProjectResult, type LinkProjectOptions, LinkedPullTarget, OAuthLoginDiscovery, ProjectMachineStatus, ProjectStatusMachine, ProjectStatusResult, PushCandidateClassification, RemoteProjectMachineTarget, ResolveApiKeyOptions, ResolvedConfiguredPullTargets, ScanProjectSourcesOptions, type VerificationExecutor, type VerificationRequest, type VerificationRunReport, type VerifyProjectOptions, briefReport, buildOAuthLoginStart, changesReport, classifyPushCandidates, createStatelyProjectConfig, discoverLinkedPullTargets, discoverMachinesInSource, discoverOAuthLogin, discoverRemoteProjectMachineTargets, formatDiscoveredMachines, formatMissingNewMachineDirMessage, formatPlanSummary, formatProjectStatus, formatStoredCredentialSource, formatVerificationJUnit, getEnvApiKey, getEnvCredential, inferInitProjectName, initProject, isFileGitDirty, linkProject, pendingReport, readGraphFile, resolveApiKey, resolveConfiguredPullTargets, resolveCredentialStatus, resolveOpenRootDir, resolveProjectStatus, resolveVerificationRequest, resourceId, run, scanProjectMachines, scanProjectSources, verifyProject, verifyReport };

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { A as briefReport, C as run, D as verifyProject, E as resolveVerificationRequest, M as pendingReport, N as readGraphFile, O as formatVerificationJUnit, P as verifyReport, S as resolveProjectStatus, T as scanProjectSources, _ as isFileGitDirty, a as discoverMachinesInSource, b as resolveCredentialStatus, c as formatDiscoveredMachines, d as formatProjectStatus, f as formatStoredCredentialSource, g as initProject, h as inferInitProjectName, i as discoverLinkedPullTargets, j as changesReport, k as createStatelyProjectConfig, l as formatMissingNewMachineDirMessage, m as getEnvCredential, n as buildOAuthLoginStart, o as discoverOAuthLogin, p as getEnvApiKey, r as classifyPushCandidates, s as discoverRemoteProjectMachineTargets, t as COMMANDS, u as formatPlanSummary, v as resolveApiKey, w as scanProjectMachines, x as resolveOpenRootDir, y as resolveConfiguredPullTargets } from "./cli-b1m4txJ7.mjs";
+import { A as formatVerificationJUnit, C as run, D as resourceId, E as linkProject, F as readGraphFile, I as verifyReport, M as briefReport, N as changesReport, O as resolveVerificationRequest, P as pendingReport, S as resolveProjectStatus, T as scanProjectSources, _ as isFileGitDirty, a as discoverMachinesInSource, b as resolveCredentialStatus, c as formatDiscoveredMachines, d as formatProjectStatus, f as formatStoredCredentialSource, g as initProject, h as inferInitProjectName, i as discoverLinkedPullTargets, j as createStatelyProjectConfig, k as verifyProject, l as formatMissingNewMachineDirMessage, m as getEnvCredential, n as buildOAuthLoginStart, o as discoverOAuthLogin, p as getEnvApiKey, r as classifyPushCandidates, s as discoverRemoteProjectMachineTargets, t as COMMANDS, u as formatPlanSummary, v as resolveApiKey, w as scanProjectMachines, x as resolveOpenRootDir, y as resolveConfiguredPullTargets } from "./cli-a0Z1igmj.mjs";
 
-export { COMMANDS, briefReport, buildOAuthLoginStart, changesReport, classifyPushCandidates, createStatelyProjectConfig, discoverLinkedPullTargets, discoverMachinesInSource, discoverOAuthLogin, discoverRemoteProjectMachineTargets, formatDiscoveredMachines, formatMissingNewMachineDirMessage, formatPlanSummary, formatProjectStatus, formatStoredCredentialSource, formatVerificationJUnit, getEnvApiKey, getEnvCredential, inferInitProjectName, initProject, isFileGitDirty, pendingReport, readGraphFile, resolveApiKey, resolveConfiguredPullTargets, resolveCredentialStatus, resolveOpenRootDir, resolveProjectStatus, resolveVerificationRequest, run, scanProjectMachines, scanProjectSources, verifyProject, verifyReport };
+export { COMMANDS, briefReport, buildOAuthLoginStart, changesReport, classifyPushCandidates, createStatelyProjectConfig, discoverLinkedPullTargets, discoverMachinesInSource, discoverOAuthLogin, discoverRemoteProjectMachineTargets, formatDiscoveredMachines, formatMissingNewMachineDirMessage, formatPlanSummary, formatProjectStatus, formatStoredCredentialSource, formatVerificationJUnit, getEnvApiKey, getEnvCredential, inferInitProjectName, initProject, isFileGitDirty, linkProject, pendingReport, readGraphFile, resolveApiKey, resolveConfiguredPullTargets, resolveCredentialStatus, resolveOpenRootDir, resolveProjectStatus, resolveVerificationRequest, resourceId, run, scanProjectMachines, scanProjectSources, verifyProject, verifyReport };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "statelyai",
-  "version": "0.13.0",
+  "version": "0.14.1",
   "description": "Command-line tools for Stately",
   "license": "MIT",
   "bin": {
@@ -24,15 +24,15 @@
     "typescript": "^5.9.3",
     "ws": "^8.21.0",
     "zod": "^4.4.1",
-    "@statelyai/mcp": "0.17.0",
-    "@statelyai/sdk": "0.39.0"
+    "@statelyai/mcp": "0.18.0",
+    "@statelyai/sdk": "0.39.1"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1",
     "tsdown": "0.21.0-beta.2",
     "vitest": "^3.2.4",
-    "@statelyai/api-contract": "0.6.5",
-    "@statelyai/editor-sync": "0.2.0"
+    "@statelyai/api-contract": "0.7.1",
+    "@statelyai/editor-sync": "0.2.2"
   },
   "oclif": {
     "bin": "statelyai",