@hexclave/shared 1.0.36 → 1.0.37

package/src/config-eval.ts

@@ -0,0 +1,140 @@
+import { existsSync, readFileSync } from "fs";
+import { createJiti } from "jiti";
+import path from "path";
+import { showOnboardingHexclaveConfigValue } from "./config-authoring";
+import { detectConfigImportPackage } from "./config-rendering";
+
+const jiti = createJiti(import.meta.url, { moduleCache: false });
+
+/**
+ * Thrown when a config file evaluates successfully but its exported `config`
+ * isn't a usable shape (missing, or not an object / "show-onboarding" string).
+ * Distinct from the underlying loader errors jiti throws, so callers can tell a
+ * malformed config apart from a file that simply failed to load.
+ */
+export class ConfigFileEvalError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ConfigFileEvalError";
+  }
+}
+
+/**
+ * Walks up from `dir` to find the nearest `package.json` and returns the
+ * best SDK package to use for the `HexclaveConfig` type import.
+ */
+export function detectImportPackageFromDir(dir: string): string | undefined {
+  let current = dir;
+  while (true) {
+    const pkgPath = path.join(current, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        const deps = [
+          ...Object.keys(pkg.dependencies ?? {}),
+          ...Object.keys(pkg.devDependencies ?? {}),
+        ];
+        return detectConfigImportPackage(deps);
+      } catch {
+        return undefined;
+      }
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+
+/** A config object, or the `"show-onboarding"` sentinel that stands in for one. */
+export type ParsedConfigValue = Record<string, unknown> | typeof showOnboardingHexclaveConfigValue;
+
+function invalidConfigShape(filePath: string): ConfigFileEvalError {
+  return new ConfigFileEvalError(`Invalid config in ${filePath}. The file must export a plain \`config\` object or "${showOnboardingHexclaveConfigValue}".`);
+}
+
+/**
+ * Evaluates config file content using jiti and returns the exported `config`
+ * value.
+ *
+ * WARNING: This executes arbitrary code via `jiti.evalModule` — only use on
+ * content that is fully operator-controlled (local filesystem). Never call
+ * this on untrusted input (e.g. content fetched from a remote repository).
+ */
+export function evalConfigFileContent(content: string, filePath: string): ParsedConfigValue {
+  if (content.trim() === "") return {};
+  const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(filePath);
+  const mod: unknown = jiti.evalModule(content, { filename: resolvedPath });
+  if (!isRecord(mod)) {
+    throw invalidConfigShape(filePath);
+  }
+  const config = mod.config;
+  if (config === undefined) {
+    throw invalidConfigShape(filePath);
+  }
+  if (typeof config === "string") {
+    if (config !== showOnboardingHexclaveConfigValue) {
+      throw new ConfigFileEvalError(`Invalid config in ${filePath}. String config values must be "${showOnboardingHexclaveConfigValue}", got "${config}".`);
+    }
+    return config;
+  }
+  if (isRecord(config)) return config;
+  throw invalidConfigShape(filePath);
+}
+
+// --- inline vitest tests ---
+
+import.meta.vitest?.test("evalConfigFileContent parses static config exports", ({ expect }) => {
+  expect(evalConfigFileContent(`
+    import type { StackConfig } from "@hexclave/js";
+    export const config: StackConfig = {
+      auth: { allowSignUp: true },
+      payments: { testMode: false },
+    };
+  `, "stack.config.ts")).toMatchInlineSnapshot(`
+    {
+      "auth": {
+        "allowSignUp": true,
+      },
+      "payments": {
+        "testMode": false,
+      },
+    }
+  `);
+});
+
+import.meta.vitest?.test("evalConfigFileContent parses show-onboarding", ({ expect }) => {
+  expect(evalConfigFileContent('export const config = "show-onboarding";', "stack.config.ts")).toBe("show-onboarding");
+});
+
+import.meta.vitest?.test("evalConfigFileContent rejects content without config export", ({ expect }) => {
+  expect(() => evalConfigFileContent("export const other = {};", "stack.config.ts")).toThrow(/must export/);
+});
+
+import.meta.vitest?.test("evalConfigFileContent rejects arbitrary string config values", ({ expect }) => {
+  expect(() => evalConfigFileContent('export const config = "arbitrary-string";', "stack.config.ts")).toThrow(/must be "show-onboarding"/);
+});
+
+import.meta.vitest?.test("evalConfigFileContent rejects unresolvable config factories", ({ expect }) => {
+  expect(() => evalConfigFileContent("export const config = makeConfig();", "stack.config.ts")).toThrow();
+});
+
+import.meta.vitest?.test("evalConfigFileContent rejects missing config import targets", ({ expect }) => {
+  expect(() => evalConfigFileContent(`
+    import missingConfigPart from "./missing-config-part";
+    export const config = { auth: missingConfigPart };
+  `, "/tmp/hexclave-missing-import-config.ts")).toThrow();
+});
+
+import.meta.vitest?.test("evalConfigFileContent surfaces invalid syntax as a loader error, not ConfigFileEvalError", ({ expect }) => {
+  // A malformed file fails inside jiti's parser, so the thrown error is a loader
+  // error — NOT a ConfigFileEvalError. Callers depend on that distinction to route
+  // it to "Failed to load config file" rather than "Invalid config".
+  const evalInvalid = () => evalConfigFileContent("export const config = {", "stack.config.ts");
+  expect(evalInvalid).toThrow();
+  expect(evalInvalid).not.toThrow(ConfigFileEvalError);
+});

package/src/config-rendering.ts

@@ -1,7 +1,6 @@
-import { existsSync, readFileSync } from "fs";
-import path from "path";
-import { hexclaveConfigFileExportsConfig, parseHexclaveConfigFileContent, renderConfigFileContent, tryParseHexclaveConfigFileContent } from "./hexclave-config-file";
-export { hexclaveConfigFileExportsConfig, parseHexclaveConfigFileContent, renderConfigFileContent, tryParseHexclaveConfigFileContent };
+import { isValidConfig, normalize } from "./config/format";
+
+const DEFAULT_CONFIG_IMPORT_PACKAGE = "@hexclave/js";
 
 /**
  * Packages that export the `HexclaveConfig` type, in priority order.
@@ -37,32 +36,30 @@ export function detectConfigImportPackage(dependencies: string[]): string | unde
 }
 
 /**
- * Walks up from `dir` to find the nearest `package.json` and returns the
- * best SDK package to use for the `HexclaveConfig` type import.
+ * Renders a config object into the source text of a `stack.config.ts` file.
  */
-export function detectImportPackageFromDir(dir: string): string | undefined {
-  let current = dir;
-  while (true) {
-    const pkgPath = path.join(current, "package.json");
-    if (existsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        const deps = [
-          ...Object.keys(pkg.dependencies ?? {}),
-          ...Object.keys(pkg.devDependencies ?? {}),
-        ];
-        return detectConfigImportPackage(deps);
-      } catch {
-        return undefined;
-      }
-    }
-    const parent = path.dirname(current);
-    if (parent === current) break;
-    current = parent;
+export function renderConfigFileContent(config: unknown, importPackage?: string): string {
+  if (!isValidConfig(config)) {
+    throw new Error("Invalid config: expected a plain object.");
   }
-  return undefined;
+
+  const droppedKeys: string[] = [];
+  const normalizedConfig = normalize(config, {
+    onDotIntoNonObject: "ignore",
+    onDotIntoNull: "empty-object",
+    droppedKeys,
+  });
+  if (droppedKeys.length > 0) {
+    throw new Error(`Config has conflicting keys that would be dropped during normalization: ${droppedKeys.map(k => JSON.stringify(k)).join(", ")}`);
+  }
+  const pkg = importPackage ?? DEFAULT_CONFIG_IMPORT_PACKAGE;
+  const importSpecifier = pkg.startsWith("@hexclave/") ? `${pkg}/config` : pkg;
+  const importLine = `import type { HexclaveConfig } from "${importSpecifier}";`;
+  return `${importLine}\n\nexport const config: HexclaveConfig = ${JSON.stringify(normalizedConfig, null, 2)};\n`;
 }
 
+// --- inline vitest tests ---
+
 import.meta.vitest?.test("renderConfigFileContent normalizes config exports", ({ expect }) => {
   expect(renderConfigFileContent({
     "payments.items.todos.displayName": "Todo Slots",
@@ -79,55 +76,6 @@ import.meta.vitest?.test("renderConfigFileContent normalizes config exports", ({
 };`);
 });
 
-import.meta.vitest?.test("parseHexclaveConfigFileContent parses static config exports", ({ expect }) => {
-  expect(parseHexclaveConfigFileContent(`
-    import type { StackConfig } from "@hexclave/js";
-    export const config: StackConfig = {
-      auth: { allowSignUp: true },
-      payments: { testMode: false },
-    };
-  `, "stack.config.ts")).toMatchInlineSnapshot(`
-    {
-      "auth": {
-        "allowSignUp": true,
-      },
-      "payments": {
-        "testMode": false,
-      },
-    }
-  `);
-});
-
-import.meta.vitest?.test("parseHexclaveConfigFileContent parses show-onboarding", ({ expect }) => {
-  expect(parseHexclaveConfigFileContent('export const config = "show-onboarding";', "stack.config.ts")).toBe("show-onboarding");
-});
-
-import.meta.vitest?.test("parseHexclaveConfigFileContent rejects dynamic config exports", ({ expect }) => {
-  expect(() => parseHexclaveConfigFileContent("export const config = makeConfig();", "stack.config.ts")).toThrow(/Unsupported config expression/);
-});
-
-import.meta.vitest?.test("tryParseHexclaveConfigFileContent returns the config for static exports", ({ expect }) => {
-  expect(tryParseHexclaveConfigFileContent("export const config = { auth: { allowSignUp: true } };", "stack.config.ts")).toEqual({
-    auth: { allowSignUp: true },
-  });
-});
-
-import.meta.vitest?.test("tryParseHexclaveConfigFileContent returns null for non-static exports", ({ expect }) => {
-  // Wrapped in a helper call (e.g. defineStackConfig) -> not a plain literal.
-  expect(tryParseHexclaveConfigFileContent("export const config = makeConfig();", "stack.config.ts")).toBeNull();
-  // References an imported value -> has structure to preserve.
-  expect(tryParseHexclaveConfigFileContent('import x from "./x.txt" with { type: "text" };\nexport const config = { a: x };', "stack.config.ts")).toBeNull();
-  // Syntax error.
-  expect(tryParseHexclaveConfigFileContent("export const config = {", "stack.config.ts")).toBeNull();
-});
-
-import.meta.vitest?.test("hexclaveConfigFileExportsConfig detects a config export", ({ expect }) => {
-  expect(hexclaveConfigFileExportsConfig("export const config = { a: 1 };", "stack.config.ts")).toBe(true);
-  expect(hexclaveConfigFileExportsConfig('import x from "./x.txt" with { type: "text" };\nexport const config = { a: x };', "stack.config.ts")).toBe(true);
-  expect(hexclaveConfigFileExportsConfig("export const notConfig = { a: 1 };", "stack.config.ts")).toBe(false);
-  expect(hexclaveConfigFileExportsConfig("export const config = {", "stack.config.ts")).toBe(false);
-});
-
 import.meta.vitest?.test("renderConfigFileContent rejects conflicting dotted keys", ({ expect }) => {
   expect(() => renderConfigFileContent({
     "a.b": 1,
@@ -152,8 +100,6 @@ import.meta.vitest?.test("renderConfigFileContent defaults to @hexclave/js", ({
 });
 
 import.meta.vitest?.test("renderConfigFileContent keeps legacy @stackframe packages on their root entrypoint", ({ expect }) => {
-  // The lightweight `/config` subpath only exists on Hexclave-branded packages;
-  // already-published @stackframe/* releases predate it.
   const content = renderConfigFileContent({}, "@stackframe/next");
   expect(content).toContain('import type { HexclaveConfig } from "@stackframe/next";');
 });
@@ -163,9 +109,7 @@ import.meta.vitest?.test("detectConfigImportPackage picks first matching package
   expect(detectConfigImportPackage(["@hexclave/react", "@hexclave/js"])).toBe("@hexclave/react");
   expect(detectConfigImportPackage(["@hexclave/js"])).toBe("@hexclave/js");
   expect(detectConfigImportPackage(["@hexclave/tanstack-start"])).toBe("@hexclave/tanstack-start");
-  // Hexclave names take priority over legacy stackframe names when both appear.
   expect(detectConfigImportPackage(["@stackframe/stack", "@hexclave/next"])).toBe("@hexclave/next");
-  // Legacy fallback still works for projects pinned to the last @stackframe/* release.
   expect(detectConfigImportPackage(["@stackframe/stack"])).toBe("@stackframe/stack");
   expect(detectConfigImportPackage(["@stackframe/template"])).toBe("@stackframe/template");
   expect(detectConfigImportPackage(["lodash", "express"])).toBeUndefined();

package/src/interface/admin-interface.ts

@@ -1,12 +1,11 @@
 import * as yup from "yup";
+import type { EnvironmentConfigOverrideOverride } from "../config/schema";
 import { KnownErrors } from "../known-errors";
-import { branchConfigSourceSchema, type RestrictedReason } from "../schema-fields";
+import { branchConfigSourceSchema, type ConfigAgentRunApi, type RestrictedReason } from "../schema-fields";
 import { AccessToken, InternalSession, RefreshToken } from "../sessions";
 import type { MoneyAmount } from "../utils/currency-constants";
-import type { Json } from "../utils/json";
 import { Result } from "../utils/results";
 import { urlString } from "../utils/urls";
-import type { PlanUsageResponse } from "./plan-usage";
 import type { AnalyticsClickmapDevice, AnalyticsClickmapKind, AnalyticsClickmapResponse, AnalyticsClickmapTokenResponse, MetricsResponse, MetricsUserCounts, UserActivityResponse } from "./admin-metrics";
 import type { AnalyticsQueryOptions, AnalyticsQueryResponse } from "./crud/analytics";
 import { EmailOutboxCrud } from "./crud/email-outbox";
@@ -15,9 +14,9 @@ import { InternalApiKeysCrud } from "./crud/internal-api-keys";
 import { ProjectPermissionDefinitionsCrud } from "./crud/project-permissions";
 import { ProjectsCrud } from "./crud/projects";
 import type {
-  AdminGetSessionReplayResponse,
   AdminGetSessionReplayAllEventsResponse,
   AdminGetSessionReplayChunkEventsResponse,
+  AdminGetSessionReplayResponse,
   AdminListSessionReplayChunksOptions,
   AdminListSessionReplayChunksResponse,
   AdminListSessionReplaysOptions,
@@ -26,7 +25,8 @@ import type {
 import { SvixTokenCrud } from "./crud/svix-token";
 import { TeamPermissionDefinitionsCrud } from "./crud/team-permissions";
 import type { Transaction, TransactionType } from "./crud/transactions";
-import { ServerAuthApplicationOptions, HexclaveServerInterface } from "./server-interface";
+import type { PlanUsageResponse } from "./plan-usage";
+import { HexclaveServerInterface, ServerAuthApplicationOptions } from "./server-interface";
 
 export type { PlanUsageResponse } from "./plan-usage";
 
@@ -834,6 +834,86 @@ export class HexclaveAdminInterface extends HexclaveServerInterface {
     );
   }
 
+  /**
+   * Reads a specific config-agent run's state (or `null`) for the linked GitHub
+   * repo. Polled by the dashboard — using the id returned by `applyConfigViaAgent`
+   * — for live progress and the review diff. Runs are independent, so each is
+   * addressed by its own id rather than "the" run on the branch.
+   */
+  async getConfigAgentRun(runId: string): Promise<ConfigAgentRunApi | null> {
+    const response = await this.sendAdminRequest(
+      `/internal/config/github/run?run_id=${encodeURIComponent(runId)}`,
+      { method: "GET" },
+      null,
+    );
+    const data = await response.json();
+    return data.agent_run ?? null;
+  }
+
+  /**
+   * Applies a dashboard config change to the linked GitHub repo by running the
+   * config agent in a sandbox (server-side). Returns immediately with the new run's
+   * `id`; poll `getConfigAgentRun(id)` for progress. The GitHub access token is the
+   * caller's own OAuth token and is used transiently server-side.
+   */
+  async applyConfigViaAgent(options: { configUpdate: EnvironmentConfigOverrideOverride, githubAccessToken: string }): Promise<{ status: "started", id: string }> {
+    const response = await this.sendAdminRequest(
+      `/internal/config/github/apply`,
+      {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          github_access_token: options.githubAccessToken,
+          config_update_string: JSON.stringify(options.configUpdate),
+        }),
+      },
+      null,
+    );
+    return await response.json();
+  }
+
+  /**
+   * Cancels a specific in-flight agent-driven config write: hard-stops the sandbox
+   * so the agent stops mid-work. Also cancels runs in `awaiting_review`. No revert
+   * — if the agent already pushed, the commit stays. Returns `not-running` if the
+   * run is gone or already terminal.
+   */
+  async cancelConfigAgentRun(runId: string): Promise<{ status: "cancelling" | "not-running" }> {
+    const response = await this.sendAdminRequest(
+      `/internal/config/github/cancel`,
+      {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ run_id: runId }),
+      },
+      null,
+    );
+    return await response.json();
+  }
+
+  /**
+   * Commits a specific run's reviewed change to GitHub. Only valid when that run is in
+   * `awaiting_review` status; the change (diff + base commit) was captured at apply time
+   * and is rebuilt + pushed via the GitHub API here, so no live sandbox is involved.
+   * Returns `not-awaiting-review` if the run isn't in a committable state.
+   */
+  async commitConfigAgentRun(runId: string, options: { githubAccessToken: string, commitMessage?: string }): Promise<{ status: "committing" | "not-awaiting-review" }> {
+    const response = await this.sendAdminRequest(
+      `/internal/config/github/commit`,
+      {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          run_id: runId,
+          github_access_token: options.githubAccessToken,
+          ...(options.commitMessage ? { commit_message: options.commitMessage } : {}),
+        }),
+      },
+      null,
+    );
+    return await response.json();
+  }
+
   async resetConfigOverrideKeys(level: "branch" | "environment", keys: string[]): Promise<void> {
     await this.sendAdminRequest(
       `/internal/config/override/${level}/reset-keys`,

package/src/schema-fields.ts

@@ -1,6 +1,7 @@
 import * as yup from "yup";
 import { KnownErrors } from "./known-errors";
 import { isBase64 } from "./utils/bytes";
+import { isValidCountryCode, normalizeCountryCode } from "./utils/country-codes";
 import { SUPPORTED_CURRENCIES, type Currency, type MoneyAmount } from "./utils/currency-constants";
 import type { DayInterval, Interval } from "./utils/dates";
 import { getProcessEnv } from "./utils/env";
@@ -9,7 +10,6 @@ import { decodeBasicAuthorizationHeader } from "./utils/http";
 import { allProviders } from "./utils/oauth";
 import { deepPlainClone, omit, typedFromEntries } from "./utils/objects";
 import { deindent } from "./utils/strings";
-import { isValidCountryCode, normalizeCountryCode } from "./utils/country-codes";
 import { isValidHostnameWithWildcards, isValidUrl } from "./utils/urls";
 import { isUuid } from "./utils/uuids";
 
@@ -884,6 +884,15 @@ export const oauthProviderAllowConnectedAccountsSchema = yupBoolean().meta({ ope
 export const oauthProviderAccountIdSchema = yupString().meta({ openapiField: { description: 'Account ID of the OAuth provider. This uniquely identifies the account on the provider side.', exampleValue: 'google-account-id-12345' } });
 export const oauthProviderProviderConfigIdSchema = yupString().meta({ openapiField: { description: 'Provider config ID of the OAuth provider. This uniquely identifies the provider config on config.json file', exampleValue: 'google' } });
 
+export const configAgentSafeErrorMessages = [
+  "The config agent failed to apply the change.",
+  "Sandbox session expired. Please retry the update.",
+  "Failed to commit and push the config changes.",
+  "The GitHub branch changed before the config commit could be pushed. Retry the update to apply the same changes on the latest branch.",
+] as const;
+export type ConfigAgentSafeErrorMessage = typeof configAgentSafeErrorMessages[number];
+export const configAgentSafeErrorMessageSchema = yupString().oneOf(configAgentSafeErrorMessages);
+
 // Headers
 export const basicAuthorizationHeaderSchema = yupString().test('is-basic-authorization-header', 'Authorization header must be in the format "Basic <base64>"', (value) => {
   if (!value) return true;
@@ -930,6 +939,9 @@ export function yupDefinedAndNonEmptyWhen<S extends yup.StringSchema>(
   });
 }
 
+// `source` describes only WHERE a branch's config came from. The ephemeral state
+// of the dashboard→GitHub config agent lives separately in `configAgentRunSchema`
+// (its own DB column), so it doesn't pollute the source descriptor.
 export const branchConfigSourceSchema = yupUnion(
   yupObject({
     type: yupString().oneOf(["pushed-from-github"]).defined(),
@@ -947,3 +959,49 @@ export const branchConfigSourceSchema = yupUnion(
     type: yupString().oneOf(["unlinked"]).defined(),
   }),
 );
+
+/**
+ * State of a single dashboard→GitHub config agent run, so the dashboard can poll for
+ * progress and surface the resulting commit (or error). Each run is one row in the
+ * `ConfigAgentRun` table, addressed by `id`; runs are NOT serialized, so many can
+ * target the same branch at once and GitHub catches conflicts at push time.
+ */
+export const configAgentRunSchema = yupObject({
+  // The run's id (the `ConfigAgentRun` row id). The dashboard polls/cancels/commits this specific run by id.
+  id: yupString().uuid().defined(),
+  // "running": agent is working; "awaiting_review": agent done, diff ready, waiting for the user to commit;
+  // "success" | "no-change" | "error" | "cancelled": terminal.
+  status: yupString().oneOf(["running", "awaiting_review", "success", "no-change", "error", "cancelled"]).defined(),
+  started_at: yupNumber().defined(),
+  finished_at: yupNumber().optional(),
+  commit_url: urlSchema.optional(),
+  error: configAgentSafeErrorMessageSchema.optional(),
+  // Vercel Sandbox id of the in-flight run, recorded only while `status` is "running"
+  // so a cancel request (a different invocation) can hard-stop the sandbox. Cleared once
+  // the change set is captured ("awaiting_review") or the run goes terminal.
+  sandbox_id: yupString().optional(),
+  // A short, SANITIZED live activity feed (recent agent actions, e.g. "Editing
+  // hexclave.config.ts", "Running: git push"). Never file contents, tool inputs, or tokens.
+  progress: yupString().optional(),
+  // Current stage, for the dashboard progress bar. Absent once terminal.
+  stage: yupString().oneOf(["initializing_sandbox", "cloning_repo", "agent_making_changes", "awaiting_review"]).optional(),
+  // The git unified diff produced by the agent, set when status becomes "awaiting_review".
+  diff: yupString().optional(),
+});
+export type ConfigAgentRunApi = yup.InferType<typeof configAgentRunSchema>;
+
+import.meta.vitest?.test("configAgentRunSchema only allows safe config-agent error messages", async ({ expect }) => {
+  expect(await configAgentRunSchema.isValid({
+    id: "00000000-0000-0000-0000-000000000000",
+    status: "error",
+    started_at: 1,
+    error: "The config agent failed to apply the change.",
+  })).toMatchInlineSnapshot(`true`);
+
+  expect(await configAgentRunSchema.isValid({
+    id: "00000000-0000-0000-0000-000000000000",
+    status: "error",
+    started_at: 1,
+    error: "ENOENT: tokenized internal failure",
+  })).toMatchInlineSnapshot(`false`);
+});

package/dist/esm/hexclave-config-file.d.ts

@@ -1,38 +0,0 @@
-//#region src/hexclave-config-file.d.ts
-declare const showOnboardingHexclaveConfigValue = "show-onboarding";
-/**
- * Renders a config object into the source text of a `stack.config.ts` file.
- *
- * Browser-safe: kept here (next to `parseHexclaveConfigFileContent`) instead of in
- * `config-rendering.ts` so dashboard client code can render config files
- * without pulling in `fs` / `path`.
- */
-declare function renderConfigFileContent(config: unknown, importPackage?: string): string;
-type ParsedStackConfig = Record<string, unknown> | typeof showOnboardingHexclaveConfigValue;
-/**
- * Like {@link parseHexclaveConfigFileContent}, but returns `null` instead of
- * throwing when the file is not a plain static config (e.g. it wraps the config
- * in a helper call, references imported values, or has a syntax error). Useful
- * for deciding whether a config file can be safely regenerated deterministically
- * or whether it has custom structure that must be preserved.
- */
-declare function tryParseHexclaveConfigFileContent(content: string, filePath: string): ParsedStackConfig | null;
-/**
- * Returns whether `content` parses as a module that exports a `config` binding.
- * Used as a lightweight structural sanity check after editing config files whose
- * values can't be evaluated by our loader (e.g. they import external text
- * files), where a full semantic comparison isn't possible.
- */
-declare function hexclaveConfigFileExportsConfig(content: string, filePath: string): boolean;
-/**
- * Returns the relative import sources (those starting with `./` or `../`)
- * declared in `content`. Used to discover the external files a config update may
- * touch — e.g. `import x from "./welcome-email.tsx" with { type: "text" }` — so
- * they can be snapshotted and rolled back if an in-place update fails. Returns
- * an empty array if the file can't be parsed.
- */
-declare function getRelativeImportSpecifiers(content: string): string[];
-declare function parseHexclaveConfigFileContent(content: string, filePath: string): ParsedStackConfig;
-//#endregion
-export { getRelativeImportSpecifiers, hexclaveConfigFileExportsConfig, parseHexclaveConfigFileContent, renderConfigFileContent, showOnboardingHexclaveConfigValue, tryParseHexclaveConfigFileContent };
-//# sourceMappingURL=hexclave-config-file.d.ts.map

package/dist/esm/hexclave-config-file.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hexclave-config-file.d.ts","names":[],"sources":["../../src/hexclave-config-file.ts"],"mappings":";cAIa,iCAAA;AAAb;;;;;AAWA;;AAXA,iBAWgB,uBAAA,CAAwB,MAAA,WAAiB,aAAA;AAAA,KAyBpD,iBAAA,GAAoB,MAAA,2BAAiC,iCAAA;;AAFzD;;;;;AAuED;iBAAgB,iCAAA,CAAkC,OAAA,UAAiB,QAAA,WAAmB,iBAAA;;;;;;;iBActE,+BAAA,CAAgC,OAAA,UAAiB,QAAA;AAAjE;;;;;AA8CA;;AA9CA,iBA8CgB,2BAAA,CAA4B,OAAA;AAAA,iBAsB5B,8BAAA,CAA+B,OAAA,UAAiB,QAAA,WAAmB,iBAAA"}