@h-rig/core 0.0.6-alpha.17 → 0.0.6-alpha.170

package/dist/src/placement.js

@@ -0,0 +1,996 @@
+// @bun
+// packages/core/src/placement.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname4, resolve as resolve4 } from "path";
+
+// packages/core/src/load-config.ts
+import { existsSync as existsSync2, mkdirSync, mkdtempSync, readFileSync as readFileSync2, readdirSync, rmSync, statSync } from "fs";
+import { isBuiltin } from "module";
+import { dirname, isAbsolute, join as join2, relative, resolve } from "path";
+import { pathToFileURL } from "url";
+import { Schema as Schema3 } from "effect";
+import { RigConfig as RigConfig3 } from "@rig/contracts";
+
+// packages/core/src/define-config.ts
+import { Schema } from "effect";
+import { RigConfig } from "@rig/contracts";
+function normalizeWorkspaceConfig(raw) {
+  const workspace = raw && typeof raw === "object" && !Array.isArray(raw) ? { ...raw } : {};
+  if (workspace.mainRepo === undefined)
+    workspace.mainRepo = ".";
+  if (workspace.checkout === undefined && workspace.isolation !== undefined)
+    workspace.checkout = workspace.isolation;
+  if (workspace.isolation === undefined && workspace.checkout !== undefined)
+    workspace.isolation = workspace.checkout;
+  return workspace;
+}
+function applyConfigDefaults(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return raw;
+  const record = raw;
+  return {
+    ...record,
+    plugins: Array.isArray(record.plugins) ? record.plugins.flat() : [],
+    workspace: normalizeWorkspaceConfig(record.workspace)
+  };
+}
+
+// packages/core/src/declarative-config.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { parse as parseToml } from "smol-toml";
+import { Schema as Schema2 } from "effect";
+import { RigConfig as RigConfig2 } from "@rig/contracts";
+
+// packages/core/src/embedded-plugins.ts
+var registered = null;
+function getStandardPluginsResolver() {
+  return registered;
+}
+var bakedProjectConfig = null;
+function getEmbeddedProjectConfig() {
+  return bakedProjectConfig;
+}
+
+// packages/core/src/declarative-config.ts
+var DECLARATIVE_CONFIG_NAMES = ["rigfig.toml", "rigfig.json"];
+function findDeclarativeConfigPath(cwd) {
+  const dir = join(cwd, ".rig");
+  for (const name of DECLARATIVE_CONFIG_NAMES) {
+    const candidate = join(dir, name);
+    if (existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
+function parseDeclarativeFile(path) {
+  const raw = readFileSync(path, "utf8");
+  const parsed = path.endsWith(".json") ? JSON.parse(raw) : parseToml(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Declarative config ${path} must parse to an object.`);
+  }
+  return parsed;
+}
+function loadDeclarativeConfig(path) {
+  const data = parseDeclarativeFile(path);
+  const standardSection = data.standard && typeof data.standard === "object" && !Array.isArray(data.standard) ? data.standard : {};
+  const useStandard = standardSection.enabled !== false;
+  let plugins = [];
+  if (useStandard) {
+    const resolver = getStandardPluginsResolver();
+    if (!resolver) {
+      throw new Error(`Declarative config ${path} needs the embedded standard plugins, but none were registered. ` + `This is a seed/boot wiring error (the binary entrypoint must import the standard-plugin registration).`);
+    }
+    plugins = resolver(data);
+  }
+  const { standard: _standardDirective, ...configFields } = data;
+  const withDefaults = applyConfigDefaults({ ...configFields, plugins });
+  const explicitPlugins = Array.isArray(withDefaults.plugins) ? [...withDefaults.plugins] : [];
+  const decoded = Schema2.decodeUnknownSync(RigConfig2)({
+    ...withDefaults,
+    plugins: explicitPlugins
+  });
+  return { ...decoded, plugins: explicitPlugins };
+}
+
+// packages/core/src/load-config.ts
+var TS_NAMES = [".rig/rig.config.ts", ".rig/rig.config.mts"];
+var JSON_NAMES = [".rig/rig.config.json"];
+function isModuleResolutionError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("Cannot find module") || message.includes("Could not resolve");
+}
+function runningFromCompiledBinary() {
+  return import.meta.url.includes("$bunfs");
+}
+function packageNameAndSubpath(specifier) {
+  if (specifier.startsWith(".") || specifier.startsWith("/") || /^[a-zA-Z]+:/.test(specifier))
+    return null;
+  const parts = specifier.split("/");
+  const packageName = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+  if (!packageName)
+    return null;
+  const rest = parts.slice(specifier.startsWith("@") ? 2 : 1).join("/");
+  return { packageName, subpath: rest ? `./${rest}` : "." };
+}
+function exportTargetFromEntry(entry) {
+  if (typeof entry === "string")
+    return entry;
+  if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+    const conditions = entry;
+    for (const key of ["bun", "import", "default", "require"]) {
+      if (typeof conditions[key] === "string")
+        return conditions[key];
+    }
+  }
+  return null;
+}
+function patternExportTarget(record, subpath) {
+  for (const [pattern, entry] of Object.entries(record)) {
+    if (!pattern.includes("*"))
+      continue;
+    const [prefix = "", suffix = ""] = pattern.split("*");
+    if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix))
+      continue;
+    const replacement = subpath.slice(prefix.length, subpath.length - suffix.length);
+    const target = exportTargetFromEntry(entry);
+    if (target)
+      return target.replace("*", replacement);
+  }
+  return null;
+}
+function exportTargetFromPackageJson(pkg, subpath) {
+  const exportsField = pkg.exports;
+  const target = (() => {
+    if (typeof exportsField === "string" && subpath === ".")
+      return exportsField;
+    if (!exportsField || typeof exportsField !== "object" || Array.isArray(exportsField))
+      return null;
+    const record = exportsField;
+    return exportTargetFromEntry(record[subpath] ?? (subpath === "." ? record["."] : undefined)) ?? patternExportTarget(record, subpath);
+  })();
+  if (target)
+    return target;
+  return subpath === "." && typeof pkg.module === "string" ? pkg.module : subpath === "." && typeof pkg.main === "string" ? pkg.main : null;
+}
+function resolvePackageDirFromBunStore(packageName, nodeModulesDir) {
+  const storeDir = join2(nodeModulesDir, ".bun");
+  if (!existsSync2(storeDir))
+    return null;
+  const encoded = packageName.replace("/", "+");
+  try {
+    const candidates = readdirSync(storeDir).filter((entry) => entry.startsWith(`${encoded}@`)).map((entry) => {
+      const candidateDir = join2(storeDir, entry, "node_modules", packageName);
+      const packageJsonPath = join2(candidateDir, "package.json");
+      if (!existsSync2(packageJsonPath))
+        return null;
+      try {
+        const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+        return {
+          dir: candidateDir,
+          sortKey: pkg.version?.trim() || entry
+        };
+      } catch {
+        return {
+          dir: candidateDir,
+          sortKey: entry
+        };
+      }
+    }).filter((candidate) => candidate !== null).sort((a, b) => b.sortKey.localeCompare(a.sortKey, undefined, { numeric: true, sensitivity: "base" }));
+    return candidates[0]?.dir ?? null;
+  } catch {
+    return null;
+  }
+}
+function resolveDirectoryModulePath(directoryPath) {
+  const packageJsonPath = join2(directoryPath, "package.json");
+  if (existsSync2(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+      const target = exportTargetFromPackageJson(pkg, ".");
+      if (target) {
+        const resolved = resolveModulePath(join2(directoryPath, target));
+        if (resolved)
+          return resolved;
+      }
+    } catch {}
+  }
+  for (const candidate of ["index.js", "index.mjs", "index.cjs", "index.ts", "index.json"]) {
+    const resolved = resolveModulePath(join2(directoryPath, candidate));
+    if (resolved)
+      return resolved;
+  }
+  return null;
+}
+function resolveModulePath(candidatePath) {
+  if (!existsSync2(candidatePath)) {
+    for (const extension of [".ts", ".mts", ".tsx", ".js", ".mjs", ".cjs", ".json"]) {
+      const withExtension = `${candidatePath}${extension}`;
+      if (existsSync2(withExtension))
+        return resolveModulePath(withExtension);
+    }
+    return null;
+  }
+  try {
+    const stat = statSync(candidatePath);
+    if (stat.isFile())
+      return candidatePath;
+    if (stat.isDirectory())
+      return resolveDirectoryModulePath(candidatePath);
+  } catch {
+    return null;
+  }
+  return null;
+}
+function resolvePackageExportFromDir(packageDir, subpath) {
+  const packageJsonPath = join2(packageDir, "package.json");
+  if (existsSync2(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+      const target = exportTargetFromPackageJson(pkg, subpath);
+      if (target) {
+        const resolved = resolveModulePath(join2(packageDir, target));
+        if (resolved)
+          return resolved;
+      }
+    } catch {
+      return null;
+    }
+  }
+  if (subpath !== ".") {
+    const legacySubpath = subpath.replace(/^\.\//, "");
+    for (const candidate of [
+      join2(packageDir, legacySubpath),
+      join2(packageDir, `${legacySubpath}.js`),
+      join2(packageDir, `${legacySubpath}.mjs`),
+      join2(packageDir, `${legacySubpath}.cjs`),
+      join2(packageDir, `${legacySubpath}.ts`),
+      join2(packageDir, `${legacySubpath}.json`)
+    ]) {
+      const resolved = resolveModulePath(candidate);
+      if (resolved)
+        return resolved;
+    }
+  }
+  return subpath === "." ? resolveDirectoryModulePath(packageDir) : null;
+}
+var runtimeBundleQueue = Promise.resolve();
+function enqueueRuntimeBundle(operation) {
+  const next = runtimeBundleQueue.then(operation, operation);
+  runtimeBundleQueue = next.then(() => {
+    return;
+  }, () => {
+    return;
+  });
+  return next;
+}
+function isWithinDir(candidatePath, rootPath) {
+  const rel = relative(resolve(rootPath), resolve(candidatePath));
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function resolvedFilePath(path, rootPath) {
+  if (!path || !isAbsolute(path))
+    return null;
+  const resolved = resolveModulePath(path);
+  if (!resolved)
+    return null;
+  return rootPath && !isWithinDir(resolved, rootPath) ? null : resolved;
+}
+function resolveProjectPackageImport(specifier, configDir) {
+  const parsed = packageNameAndSubpath(specifier);
+  if (!parsed)
+    return null;
+  const nodeModulesDir = join2(configDir, "node_modules");
+  const directPackageDir = join2(nodeModulesDir, parsed.packageName);
+  const packageDir = existsSync2(join2(directPackageDir, "package.json")) ? directPackageDir : resolvePackageDirFromBunStore(parsed.packageName, nodeModulesDir);
+  return packageDir ? resolvePackageExportFromDir(packageDir, parsed.subpath) : null;
+}
+function canImportRigWorkspacePackagesDirectly(source, configDir) {
+  const packageNames = new Set;
+  for (const match of source.matchAll(/(?:from\s*|import\s*\(\s*|import\s*)["'](@rig\/[^"']+)["']/g)) {
+    const parsed = packageNameAndSubpath(match[1] ?? "");
+    if (parsed?.packageName)
+      packageNames.add(parsed.packageName);
+  }
+  if (packageNames.size === 0)
+    return false;
+  for (const packageName of packageNames) {
+    const shortName = packageName.replace(/^@rig\//, "");
+    const manifestPath = join2(configDir, "packages", shortName, "package.json");
+    if (!existsSync2(manifestPath))
+      return false;
+    try {
+      const parsed = JSON.parse(readFileSync2(manifestPath, "utf8"));
+      if (parsed.name !== packageName)
+        return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+async function importConfigViaRuntimeBundleUnserialized(configPath) {
+  const bun = globalThis.Bun;
+  if (!bun?.build) {
+    throw new Error(`Failed to import ${configPath}: bare imports could not be resolved and no Bun.build runtime bundler is available.`);
+  }
+  const RUNTIME_ONLY_EXTERNAL_PACKAGES = new Set(["effect", "mupdf", "fastembed", "onnxruntime-node", "markit-ai"]);
+  const configDir = dirname(configPath);
+  const UNRESOLVED_NAMESPACE = "rig-config-unresolved";
+  const unresolvedLocalPlugin = {
+    name: "rig-config-unresolved-local",
+    setup(build) {
+      build.onLoad({ filter: /\.(?:html|txt)$/ }, (args) => ({
+        loader: "js",
+        contents: `export default ${JSON.stringify(readFileSync2(args.path, "utf8"))};
+`
+      }));
+      build.onResolve({ filter: /.*/ }, (args) => {
+        const directFilePath = resolvedFilePath(args.path, configDir);
+        if (directFilePath)
+          return { path: directFilePath };
+        const packageImport = packageNameAndSubpath(args.path);
+        if (packageImport && (packageImport.packageName.startsWith("@rig/") || RUNTIME_ONLY_EXTERNAL_PACKAGES.has(packageImport.packageName))) {
+          return { path: args.path, external: true };
+        }
+        const projectPackagePath = resolveProjectPackageImport(args.path, configDir);
+        if (projectPackagePath)
+          return { path: projectPackagePath };
+        if (/^(?:node|bun):/.test(args.path) || isBuiltin(args.path))
+          return;
+        if (packageImport)
+          return { path: args.path, external: true };
+        const parentCandidates = args.path.startsWith(".") ? [args.importer && isAbsolute(args.importer) ? dirname(args.importer) : null, configDir].filter((value) => Boolean(value)) : [args.importer && isAbsolute(args.importer) ? dirname(args.importer) : configDir];
+        for (const parent2 of parentCandidates) {
+          const filePath = resolvedFilePath(resolve(parent2, args.path), configDir);
+          if (filePath)
+            return { path: filePath };
+        }
+        const parent = parentCandidates[0] ?? configDir;
+        try {
+          const resolved = bun.resolveSync?.(args.path, parent) ?? resolve(parent, args.path);
+          const filePath = resolvedFilePath(resolved, configDir);
+          if (filePath)
+            return { path: filePath };
+        } catch {}
+        return { path: args.path, namespace: UNRESOLVED_NAMESPACE };
+      });
+      build.onLoad({ filter: /.*/, namespace: UNRESOLVED_NAMESPACE }, (args) => ({
+        loader: "js",
+        contents: `module.exports = {};
+throw new Error(${JSON.stringify(`Failed to bundle ${configPath}: Could not resolve local import "${args.path}". Maybe you need to fix a relative import in rig.config.ts or install project deps.`)});
+`
+      }));
+    }
+  };
+  const result = await bun.build({
+    entrypoints: [configPath],
+    target: "bun",
+    external: ["effect", "mupdf", "fastembed", "onnxruntime-node", "markit-ai"],
+    format: "esm",
+    throw: false,
+    packages: "bundle",
+    plugins: [unresolvedLocalPlugin]
+  });
+  if (!result.success || !result.outputs[0]) {
+    const detail = result.logs.map((log) => String(log)).join(`
+`);
+    throw new Error(`Failed to bundle ${configPath}: ${detail || "unknown bundler error"}`);
+  }
+  const bundleParentDir = join2(configDir, ".rig", "tmp");
+  mkdirSync(bundleParentDir, { recursive: true });
+  const dir = mkdtempSync(join2(bundleParentDir, "rig-config-bundle-"));
+  try {
+    const bundledPath = join2(dir, "rig.config.bundled.js");
+    await bun.write(bundledPath, await result.outputs[0].text());
+    return await import(pathToFileURL(bundledPath).href);
+  } finally {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {}
+  }
+}
+async function loadConfig(cwd) {
+  const baked = getEmbeddedProjectConfig();
+  if (baked && resolve(baked.projectRoot) === resolve(cwd)) {
+    return decodeExplicitPluginConfig(baked.raw);
+  }
+  for (const name of TS_NAMES) {
+    const p = join2(cwd, name);
+    if (existsSync2(p)) {
+      const mod = await enqueueRuntimeBundle(async () => {
+        if (runningFromCompiledBinary()) {
+          return importConfigViaRuntimeBundleUnserialized(p);
+        }
+        const source = readFileSync2(p, "utf8");
+        const importsRigHostPackages = /(?:import\s+[^;]*?from\s*|import\s*\()\s*["']@rig\//.test(source);
+        if (importsRigHostPackages && !canImportRigWorkspacePackagesDirectly(source, cwd)) {
+          return importConfigViaRuntimeBundleUnserialized(p);
+        }
+        try {
+          return await import(pathToFileURL(p).href);
+        } catch (error) {
+          if (!isModuleResolutionError(error))
+            throw error;
+          return importConfigViaRuntimeBundleUnserialized(p);
+        }
+      });
+      const raw = mod.default ?? mod.config;
+      return decodeExplicitPluginConfig(raw);
+    }
+  }
+  const declarativePath = findDeclarativeConfigPath(cwd);
+  if (declarativePath) {
+    return loadDeclarativeConfig(declarativePath);
+  }
+  for (const name of JSON_NAMES) {
+    const p = join2(cwd, name);
+    if (existsSync2(p)) {
+      const raw = JSON.parse(readFileSync2(p, "utf-8"));
+      return decodeExplicitPluginConfig(raw);
+    }
+  }
+  throw new Error(`no .rig/rig.config.{ts,mts,json} or .rig/rigfig.{toml,json} found in ${cwd}`);
+}
+function decodeExplicitPluginConfig(raw) {
+  const withDefaults = applyConfigDefaults(raw);
+  const explicitPlugins = Array.isArray(withDefaults.plugins) ? [...withDefaults.plugins] : [];
+  const decoded = Schema3.decodeUnknownSync(RigConfig3)({
+    ...withDefaults,
+    plugins: explicitPlugins
+  });
+  return { ...decoded, plugins: explicitPlugins };
+}
+
+// packages/core/src/remote-config.ts
+import { randomUUID } from "crypto";
+import { chmodSync, existsSync as existsSync4, mkdirSync as mkdirSync2, mkdtempSync as mkdtempSync2, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { homedir, tmpdir } from "os";
+import { dirname as dirname3, join as join3, resolve as resolve3 } from "path";
+import { parse as parseToml2, stringify as stringifyToml } from "smol-toml";
+
+// packages/core/src/authority-paths.ts
+import { existsSync as existsSync3 } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+function normalizeOptionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function resolveAuthorityPaths(projectRoot) {
+  const normalizedRoot = resolve2(projectRoot);
+  const stateRoot = resolveAuthorityStateRoot(normalizedRoot);
+  const stateDir = resolveAuthorityStateDir(normalizedRoot);
+  return {
+    projectRoot: normalizedRoot,
+    harnessRoot: resolve2(normalizedRoot, "rig"),
+    runsDir: resolve2(stateRoot, "runs"),
+    remoteDir: resolve2(stateRoot, "remote"),
+    stateDir,
+    remoteEndpointsPath: resolve2(stateRoot, "remote", "endpoints.toml"),
+    remoteSecretsPath: resolve2(stateDir, "remote-secrets.toml")
+  };
+}
+function resolveAuthorityStateRoot(projectRoot) {
+  const normalizedRoot = resolve2(projectRoot);
+  const taskWorkspace = normalizeOptionalString(process.env.RIG_TASK_WORKSPACE);
+  if (taskWorkspace) {
+    return resolve2(taskWorkspace, ".rig");
+  }
+  const stateDir = normalizeOptionalString(process.env.RIG_STATE_DIR);
+  if (stateDir) {
+    return dirname2(resolve2(stateDir));
+  }
+  const logsDir = normalizeOptionalString(process.env.RIG_LOGS_DIR);
+  if (logsDir) {
+    return dirname2(resolve2(logsDir));
+  }
+  const sessionFile = normalizeOptionalString(process.env.RIG_SESSION_FILE);
+  if (sessionFile) {
+    return dirname2(dirname2(resolve2(sessionFile)));
+  }
+  const projectStateRoot = resolve2(normalizedRoot, ".rig");
+  if (existsSync3(projectStateRoot)) {
+    return projectStateRoot;
+  }
+  return resolve2(normalizedRoot, ".rig");
+}
+function resolveAuthorityStateDir(projectRoot) {
+  const explicit = normalizeOptionalString(process.env.RIG_STATE_DIR);
+  if (explicit) {
+    return resolve2(explicit);
+  }
+  return resolve2(resolveAuthorityStateRoot(projectRoot), "state");
+}
+
+// packages/core/src/remote-config.ts
+var DEFAULT_REMOTE_PORT = 7890;
+var BACKBONE_DEFAULTS_KEY = Symbol.for("rig.remote-config.backbone-defaults");
+function backboneDefaultsState() {
+  const global = globalThis;
+  return global[BACKBONE_DEFAULTS_KEY] ??= {};
+}
+function resolveSshTarget(env = process.env) {
+  return normalizeString(env.RIG_SSH_TARGET) || backboneDefaultsState().sshTarget || "";
+}
+var REMOTES_CONFIG_PATH = join3(homedir(), ".config", "rig", "remotes.toml");
+
+class RemoteCliError extends Error {
+  code;
+  exitCode;
+  details;
+  constructor(code, message, exitCode = 1, details) {
+    super(message);
+    this.name = "RemoteCliError";
+    this.code = code;
+    this.exitCode = exitCode;
+    this.details = details;
+  }
+}
+function loadRemotesConfig(configPath = REMOTES_CONFIG_PATH) {
+  if (!existsSync4(configPath)) {
+    return { version: 1, remotes: {} };
+  }
+  try {
+    const content = readFileSync3(configPath, "utf-8");
+    if (!content.trim()) {
+      return { version: 1, remotes: {} };
+    }
+    const parsed = parseToml2(content);
+    return {
+      version: parsed.version ?? 1,
+      remotes: parsed.remotes ?? {}
+    };
+  } catch (error) {
+    throw new RemoteCliError("RIG_REMOTE_CONFIG_PARSE_ERROR", `Failed to parse remotes config at ${configPath}: ${error instanceof Error ? error.message : String(error)}`, 2, { configPath });
+  }
+}
+function saveRemotesConfig(config, configPath = REMOTES_CONFIG_PATH) {
+  mkdirSync2(dirname3(configPath), { recursive: true });
+  writeFileSync(configPath, `${stringifyToml(config).trimEnd()}
+`, "utf-8");
+  try {
+    chmodSync(configPath, 384);
+  } catch {}
+}
+function readTomlFile(path, fallback) {
+  if (!existsSync4(path))
+    return fallback;
+  const raw = readFileSync3(path, "utf8");
+  if (!raw.trim())
+    return fallback;
+  return parseToml2(raw);
+}
+function writeTomlFile(path, value) {
+  mkdirSync2(dirname3(path), { recursive: true });
+  writeFileSync(path, `${stringifyToml(value).trimEnd()}
+`, "utf8");
+}
+function normalizeStringArray(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.map((entry) => normalizeString(entry)).filter((entry) => entry !== "");
+}
+function normalizePort(value) {
+  const port = typeof value === "number" ? value : Number(value);
+  return Number.isInteger(port) && port > 0 && port <= 65535 ? port : DEFAULT_REMOTE_PORT;
+}
+function normalizeRegistryBaseUrl(raw) {
+  const trimmed = raw.replace(/\/+$/, "");
+  if (!trimmed)
+    return trimmed;
+  return /\/registry$/.test(trimmed) ? trimmed : `${trimmed}/registry`;
+}
+function loadRemoteEndpointsToml(projectRoot) {
+  const paths = resolveAuthorityPaths(projectRoot);
+  const parsed = readTomlFile(paths.remoteEndpointsPath, { version: 1, endpoints: {} });
+  return {
+    version: parsed.version ?? 1,
+    endpoints: parsed.endpoints ?? {}
+  };
+}
+function loadRemoteSecretsToml(projectRoot) {
+  const paths = resolveAuthorityPaths(projectRoot);
+  const parsed = readTomlFile(paths.remoteSecretsPath, { version: 1, secrets: {} });
+  return {
+    version: parsed.version ?? 1,
+    secrets: parsed.secrets ?? {}
+  };
+}
+function readJsonRecordFile(path) {
+  try {
+    if (!existsSync4(path))
+      return {};
+    const raw = readFileSync3(path, "utf8");
+    if (!raw.trim())
+      return {};
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function coerceString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function forceLocalTransport(env) {
+  return env.RIG_FORCE_LOCAL === "1" || env.RIG_FORCE_LOCAL === "true";
+}
+function resolveDispatchTransportPlacement(projectRoot, env = process.env) {
+  if (forceLocalTransport(env)) {
+    return { kind: "local", alias: "local", sshTarget: null, selected: null };
+  }
+  const stateDir = resolveAuthorityPaths(projectRoot).stateDir;
+  const conn = readJsonRecordFile(resolve3(stateDir, "connection.json"));
+  const selectedAlias = normalizeString(env.RIG_REMOTE_ALIAS) || coerceString(conn.selected);
+  if (selectedAlias === "local") {
+    return { kind: "local", alias: "local", sshTarget: null, selected: null };
+  }
+  const selected = resolveSelectedRemote(projectRoot, env);
+  const sshTarget = selected?.sshTarget ?? resolveSshTarget(env);
+  if (!sshTarget) {
+    return { kind: "local", alias: "local", sshTarget: null, selected: null };
+  }
+  return { kind: "remote", alias: selected?.alias ?? sshTarget, sshTarget, selected };
+}
+function resolveSelectedRemote(projectRoot, env = process.env) {
+  const stateDir = resolveAuthorityPaths(projectRoot).stateDir;
+  const conn = readJsonRecordFile(resolve3(stateDir, "connection.json"));
+  const selected = normalizeString(env.RIG_REMOTE_ALIAS) || coerceString(conn.selected);
+  if (!selected || selected === "local")
+    return null;
+  const endpoints = Object.values(loadRemoteEndpointsToml(projectRoot).endpoints ?? {});
+  const match = endpoints.find((entry) => normalizeString(entry.alias) === selected);
+  if (!match) {
+    if (selected === "remote") {
+      const sshTarget = resolveSshTarget(env);
+      if (!sshTarget)
+        return null;
+      return {
+        alias: "remote",
+        host: sshTarget,
+        port: 22,
+        sshTarget,
+        checkout: coerceString(conn.serverProjectRoot) || null,
+        registryBaseUrl: null,
+        secretRef: null
+      };
+    }
+    return null;
+  }
+  const host = normalizeString(match.host) || selected;
+  const explicitRegistryUrl = normalizeString(env.RIG_REGISTRY_URL) || normalizeString(env.REGISTRY_URL);
+  const registryBaseUrl = explicitRegistryUrl ? normalizeRegistryBaseUrl(explicitRegistryUrl) : null;
+  return {
+    alias: selected,
+    host,
+    port: normalizePort(match.port),
+    sshTarget: host || normalizeString(match.alias) || coerceString(conn.serverProjectRootAlias),
+    checkout: coerceString(conn.serverProjectRoot) || null,
+    registryBaseUrl,
+    secretRef: normalizeString(match.secret_ref) || null
+  };
+}
+function saveRemoteEndpointsToml(projectRoot, payload) {
+  writeTomlFile(resolveAuthorityPaths(projectRoot).remoteEndpointsPath, payload);
+}
+function saveRemoteSecretsToml(projectRoot, payload) {
+  const paths = resolveAuthorityPaths(projectRoot);
+  writeTomlFile(paths.remoteSecretsPath, payload);
+  try {
+    chmodSync(paths.remoteSecretsPath, 384);
+  } catch {}
+}
+function listAuthorityRemoteEndpoints(projectRoot) {
+  const endpoints = loadRemoteEndpointsToml(projectRoot).endpoints ?? {};
+  const secrets = loadRemoteSecretsToml(projectRoot).secrets ?? {};
+  return Object.values(endpoints).map((entry) => {
+    const token = secrets[entry.secret_ref] ?? "";
+    return {
+      id: entry.id,
+      alias: entry.alias,
+      host: entry.host,
+      port: normalizePort(entry.port),
+      token,
+      autoConnect: Boolean(entry.auto_connect),
+      addedAt: entry.created_at,
+      updatedAt: entry.updated_at,
+      lastConnectedAt: normalizeString(entry.last_connected_at) || null,
+      labels: normalizeStringArray(entry.labels),
+      capabilities: normalizeStringArray(entry.capabilities),
+      transport: normalizeString(entry.transport) || "websocket",
+      secretRef: entry.secret_ref
+    };
+  }).sort((left, right) => left.alias.localeCompare(right.alias));
+}
+function nextRemoteEndpointRecord(input) {
+  const timestamp = new Date().toISOString();
+  const secretRef = input.existing?.secret_ref ?? randomUUID();
+  return {
+    record: {
+      id: input.endpointId ?? input.existing?.id ?? randomUUID(),
+      alias: input.alias,
+      host: input.host,
+      port: normalizePort(input.port),
+      transport: normalizeString(input.transport) || normalizeString(input.existing?.transport) || "websocket",
+      auto_connect: input.autoConnect ?? input.existing?.auto_connect ?? false,
+      labels: input.labels ?? normalizeStringArray(input.existing?.labels),
+      capabilities: input.capabilities ?? normalizeStringArray(input.existing?.capabilities),
+      secret_ref: secretRef,
+      created_at: input.existing?.created_at ?? timestamp,
+      updated_at: timestamp,
+      last_connected_at: input.existing?.last_connected_at ?? null
+    },
+    secretRef
+  };
+}
+function upsertAuthorityRemoteEndpoint(projectRoot, input) {
+  const endpointsToml = loadRemoteEndpointsToml(projectRoot);
+  const secretsToml = loadRemoteSecretsToml(projectRoot);
+  const existing = Object.values(endpointsToml.endpoints ?? {}).find((entry) => entry.alias === input.alias) ?? null;
+  const { record, secretRef } = nextRemoteEndpointRecord({
+    existing,
+    alias: input.alias,
+    host: input.host,
+    port: input.port,
+    token: input.token,
+    ...input.endpointId !== undefined ? { endpointId: input.endpointId } : {},
+    ...input.autoConnect !== undefined ? { autoConnect: input.autoConnect } : {},
+    ...input.transport !== undefined ? { transport: input.transport } : {},
+    ...input.labels !== undefined ? { labels: input.labels } : {},
+    ...input.capabilities !== undefined ? { capabilities: input.capabilities } : {}
+  });
+  endpointsToml.endpoints = {
+    ...endpointsToml.endpoints ?? {},
+    [record.id]: record
+  };
+  secretsToml.secrets = {
+    ...secretsToml.secrets ?? {},
+    [secretRef]: input.token
+  };
+  saveRemoteEndpointsToml(projectRoot, endpointsToml);
+  saveRemoteSecretsToml(projectRoot, secretsToml);
+  return listAuthorityRemoteEndpoints(projectRoot).find((entry) => entry.id === record.id);
+}
+function removeAuthorityRemoteEndpoint(projectRoot, endpointIdOrAlias) {
+  const endpointsToml = loadRemoteEndpointsToml(projectRoot);
+  const secretsToml = loadRemoteSecretsToml(projectRoot);
+  const entry = Object.values(endpointsToml.endpoints ?? {}).find((candidate) => candidate.id === endpointIdOrAlias || candidate.alias === endpointIdOrAlias);
+  if (!entry)
+    return false;
+  const nextEndpoints = { ...endpointsToml.endpoints ?? {} };
+  delete nextEndpoints[entry.id];
+  const nextSecrets = { ...secretsToml.secrets ?? {} };
+  delete nextSecrets[entry.secret_ref];
+  saveRemoteEndpointsToml(projectRoot, { version: endpointsToml.version ?? 1, endpoints: nextEndpoints });
+  saveRemoteSecretsToml(projectRoot, { version: secretsToml.version ?? 1, secrets: nextSecrets });
+  return true;
+}
+function listManagedRemoteEndpoints(configPath = REMOTES_CONFIG_PATH, projectRoot) {
+  if (projectRoot) {
+    return listAuthorityRemoteEndpoints(projectRoot).map((entry) => ({
+      id: entry.id,
+      alias: entry.alias,
+      host: entry.host,
+      port: entry.port,
+      token: entry.token,
+      addedAt: entry.addedAt,
+      lastConnected: entry.lastConnectedAt
+    }));
+  }
+  const config = loadRemotesConfig(configPath);
+  return Object.entries(config.remotes ?? {}).map(([alias, entry]) => ({
+    id: alias,
+    alias,
+    host: normalizeString(entry.host) || "",
+    port: Number.isFinite(entry.port) ? Number(entry.port) : DEFAULT_REMOTE_PORT,
+    token: normalizeString(entry.token) || "",
+    addedAt: normalizeString(entry.addedAt) || null,
+    lastConnected: normalizeString(entry.lastConnected) || null
+  })).sort((left, right) => left.alias.localeCompare(right.alias));
+}
+function upsertManagedRemoteEndpoint(input, configPath = REMOTES_CONFIG_PATH, projectRoot) {
+  if (projectRoot) {
+    const saved = upsertAuthorityRemoteEndpoint(projectRoot, {
+      ...input,
+      token: input.token ?? ""
+    });
+    return {
+      id: saved.id,
+      alias: saved.alias,
+      host: saved.host,
+      port: saved.port,
+      token: saved.token,
+      addedAt: saved.addedAt,
+      lastConnected: saved.lastConnectedAt
+    };
+  }
+  const config = loadRemotesConfig(configPath);
+  const existing = config.remotes?.[input.alias];
+  const nextEntry = {
+    host: input.host,
+    port: input.port,
+    ...input.token !== undefined ? { token: input.token } : {},
+    addedAt: normalizeString(existing?.addedAt) || new Date().toISOString(),
+    ...normalizeString(existing?.lastConnected) ? { lastConnected: normalizeString(existing?.lastConnected) } : {}
+  };
+  const nextConfig = {
+    version: config.version ?? 1,
+    remotes: {
+      ...config.remotes ?? {},
+      [input.alias]: nextEntry
+    }
+  };
+  saveRemotesConfig(nextConfig, configPath);
+  return {
+    id: input.alias,
+    alias: input.alias,
+    host: input.host,
+    port: input.port,
+    token: input.token ?? "",
+    addedAt: nextEntry.addedAt ?? null,
+    lastConnected: nextEntry.lastConnected ?? null
+  };
+}
+function removeManagedRemoteEndpoint(alias, configPath = REMOTES_CONFIG_PATH, projectRoot) {
+  if (projectRoot) {
+    return removeAuthorityRemoteEndpoint(projectRoot, alias);
+  }
+  const config = loadRemotesConfig(configPath);
+  if (!config.remotes?.[alias]) {
+    return false;
+  }
+  const nextRemotes = { ...config.remotes ?? {} };
+  delete nextRemotes[alias];
+  saveRemotesConfig({
+    version: config.version ?? 1,
+    remotes: nextRemotes
+  }, configPath);
+  return true;
+}
+function normalizeString(value) {
+  if (!value) {
+    return "";
+  }
+  return value.trim();
+}
+
+// packages/core/src/placement.ts
+var DEFAULT_REMOTE_PORT2 = 22;
+function resolveRepoConnectionPath(projectRoot) {
+  return resolve4(projectRoot, ".rig", "state", "connection.json");
+}
+function readJsonFile(path) {
+  if (!existsSync5(path))
+    return null;
+  try {
+    return JSON.parse(readFileSync4(path, "utf8"));
+  } catch (error) {
+    throw new Error(`Invalid Rig connection state at ${path}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function writeJsonFile(path, value) {
+  mkdirSync3(dirname4(path), { recursive: true });
+  writeFileSync2(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function readSelection(projectRoot) {
+  const payload = readJsonFile(resolveRepoConnectionPath(projectRoot));
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  const record = payload;
+  const selected = typeof record.selected === "string" ? record.selected.trim() : "";
+  if (!selected)
+    return null;
+  const serverProjectRoot = typeof record.serverProjectRoot === "string" && record.serverProjectRoot.trim() ? record.serverProjectRoot.trim() : undefined;
+  const serverProjectRootAlias = typeof record.serverProjectRootAlias === "string" && record.serverProjectRootAlias.trim() ? record.serverProjectRootAlias.trim() : undefined;
+  const serverProjectRootBaseUrl = typeof record.serverProjectRootBaseUrl === "string" && record.serverProjectRootBaseUrl.trim() ? record.serverProjectRootBaseUrl.trim().replace(/\/+$/, "") : undefined;
+  return {
+    selected,
+    ...typeof record.project === "string" ? { project: record.project } : {},
+    ...typeof record.linkedAt === "string" ? { linkedAt: record.linkedAt } : {},
+    ...serverProjectRoot !== undefined ? { serverProjectRoot } : {},
+    ...serverProjectRootAlias !== undefined ? { serverProjectRootAlias } : {},
+    ...serverProjectRootBaseUrl !== undefined ? { serverProjectRootBaseUrl } : {}
+  };
+}
+var readRepoConnection = readSelection;
+function writeSelection(projectRoot, state) {
+  writeJsonFile(resolveRepoConnectionPath(projectRoot), state);
+}
+var writeRepoConnection = writeSelection;
+function endpointPlacement(endpoint, projectRoot, selected) {
+  return {
+    alias: endpoint.alias,
+    kind: "remote",
+    host: endpoint.host,
+    port: endpoint.port,
+    projectRoot,
+    status: selected === endpoint.alias ? "selected" : "ready"
+  };
+}
+async function readPlacement(projectRoot, env = process.env) {
+  const config = await loadConfig(resolve4(projectRoot));
+  const placement = resolveDispatchTransportPlacement(projectRoot, env);
+  const selected = placement.selected;
+  return {
+    alias: placement.alias,
+    kind: placement.kind,
+    host: placement.kind === "remote" ? selected?.host ?? placement.sshTarget : null,
+    port: placement.kind === "remote" ? selected?.port ?? DEFAULT_REMOTE_PORT2 : null,
+    projectRoot,
+    status: "ready",
+    taskSource: config.taskSource.kind
+  };
+}
+var readSelectedTarget = readPlacement;
+function listPlacements(projectRoot) {
+  const selected = readSelection(projectRoot)?.selected ?? "local";
+  const builtins = [
+    { alias: "local", kind: "local", projectRoot, status: selected === "local" ? "selected" : "ready" },
+    { alias: "remote", kind: "remote", host: resolveSshTarget() || null, port: DEFAULT_REMOTE_PORT2, projectRoot, status: selected === "remote" ? "selected" : "ready" }
+  ];
+  return [...builtins, ...listManagedRemoteEndpoints(undefined, projectRoot).map((endpoint) => endpointPlacement(endpoint, projectRoot, selected))];
+}
+var listServerTargets = listPlacements;
+function selectPlacement(projectRoot, alias, options = {}) {
+  const cleanAlias = alias.trim();
+  if (!cleanAlias)
+    throw new Error("Placement alias is required.");
+  if (cleanAlias !== "local" && cleanAlias !== "remote") {
+    const known = listManagedRemoteEndpoints(undefined, projectRoot).some((endpoint) => endpoint.alias === cleanAlias);
+    if (!known)
+      throw new Error(`Unknown remote endpoint: ${cleanAlias}`);
+  }
+  if (!options.dryRun) {
+    const prev = readSelection(projectRoot);
+    writeSelection(projectRoot, { ...prev ?? { selected: "local" }, selected: cleanAlias });
+  }
+  return listPlacements(projectRoot).find((placement) => placement.alias === cleanAlias) ?? { alias: cleanAlias, kind: cleanAlias === "local" ? "local" : "remote", projectRoot };
+}
+var selectServerTarget = selectPlacement;
+function addPlacement(projectRoot, input, options = {}) {
+  const alias = input.alias.trim();
+  const host = input.host.trim();
+  if (!alias || !host)
+    throw new Error("Remote placement requires alias and host.");
+  const port = input.port ?? DEFAULT_REMOTE_PORT2;
+  if (!Number.isFinite(port) || port <= 0 || port > 65535)
+    throw new Error(`Invalid remote port: ${port}`);
+  if (options.dryRun)
+    return { alias, kind: "remote", host, port, projectRoot, status: "dry-run" };
+  const saved = upsertManagedRemoteEndpoint({ alias, host, port, ...input.token ? { token: input.token } : {} }, undefined, projectRoot);
+  if (input.select)
+    selectPlacement(projectRoot, saved.alias);
+  return endpointPlacement(saved, projectRoot, readSelection(projectRoot)?.selected ?? "local");
+}
+var addRemoteTarget = addPlacement;
+function removePlacement(projectRoot, alias, options = {}) {
+  const cleanAlias = alias.trim();
+  if (!cleanAlias)
+    throw new Error("Remote placement alias is required.");
+  if (cleanAlias === "local" || cleanAlias === "remote")
+    throw new Error(`Cannot remove built-in placement: ${cleanAlias}`);
+  const removed = options.dryRun ? true : removeManagedRemoteEndpoint(cleanAlias, undefined, projectRoot);
+  if (removed && !options.dryRun && readSelection(projectRoot)?.selected === cleanAlias) {
+    const prev = readSelection(projectRoot);
+    writeSelection(projectRoot, { ...prev ?? { selected: "local" }, selected: "local" });
+  }
+  return { alias: cleanAlias, removed };
+}
+var removeServerTarget = removePlacement;
+export {
+  writeSelection,
+  writeRepoConnection,
+  selectServerTarget,
+  selectPlacement,
+  resolveRepoConnectionPath,
+  removeServerTarget,
+  removePlacement,
+  readSelection,
+  readSelectedTarget,
+  readRepoConnection,
+  readPlacement,
+  listServerTargets,
+  listPlacements,
+  addRemoteTarget,
+  addPlacement
+};