@tscircuit/cli 0.1.1809 → 0.1.1811

package/dist/lib/index.js

@@ -39247,8 +39247,8 @@ var require_utils = __commonJS((exports2, module2) => {
     }
     return ind;
   }
-  function removeDotSegments(path4) {
-    let input = path4;
+  function removeDotSegments(path5) {
+    let input = path5;
     const output = [];
     let nextSlash = -1;
     let len = 0;
@@ -39491,8 +39491,8 @@ var require_schemes = __commonJS((exports2, module2) => {
       wsComponent.secure = undefined;
     }
     if (wsComponent.resourceName) {
-      const [path4, query] = wsComponent.resourceName.split("?");
-      wsComponent.path = path4 && path4 !== "/" ? path4 : undefined;
+      const [path5, query] = wsComponent.resourceName.split("?");
+      wsComponent.path = path5 && path5 !== "/" ? path5 : undefined;
       wsComponent.query = query;
       wsComponent.resourceName = undefined;
     }
@@ -43430,12 +43430,12 @@ var require_dist5 = __commonJS((exports2, module2) => {
       throw new Error(`Unknown format "${name}"`);
     return f;
   };
-  function addFormats(ajv, list, fs2, exportName) {
+  function addFormats(ajv, list, fs3, exportName) {
     var _a;
     var _b;
     (_a = (_b = ajv.opts.code).formats) !== null && _a !== undefined || (_b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`);
     for (const f of list)
-      ajv.addFormat(f, fs2[f]);
+      ajv.addFormat(f, fs3[f]);
   }
   module2.exports = exports2 = formatsPlugin;
   Object.defineProperty(exports2, "__esModule", { value: true });
@@ -65757,7 +65757,7 @@ var getNodeHandler = (winterSpec, { port, middleware = [] }) => {
   }));
 };
 // package.json
-var version = "0.1.1808";
+var version = "0.1.1809";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -65772,7 +65772,7 @@ var package_default = {
     "@tscircuit/check-shorts": "https://jscdn.tscircuit.com/@tscircuit/check-shorts/0.0.12.tgz",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.6",
     "@tscircuit/circuit-json-routing-analysis": "^0.0.6",
-    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#b6d5fe675adc26a2fc988aa081e6fb51e6bf696a",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#bb0b41d80c9714695b498e182c2a558f1e0ceb2d",
     "@tscircuit/eval": "^0.0.1016",
     "@tscircuit/fake-snippets": "^0.0.182",
     "@tscircuit/file-server": "^0.0.32",
@@ -66838,11 +66838,91 @@ var winterSpec = {
 };
 var stdin_default = winterSpec;
 
+// lib/shared/get-platform-config-with-cli-defaults.ts
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { getPlatformConfig } from "@tscircuit/eval/platform-config";
+function createLocalCacheEngine(cacheDir = path.join(process.cwd(), ".tscircuit", "cache")) {
+  return {
+    getItem: (key) => {
+      try {
+        const hash = createHash("md5").update(key).digest("hex");
+        const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
+        const filePath = path.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        return fs.readFileSync(filePath, "utf-8");
+      } catch {
+        return null;
+      }
+    },
+    setItem: (key, value) => {
+      try {
+        fs.mkdirSync(cacheDir, { recursive: true });
+        const hash = createHash("md5").update(key).digest("hex");
+        const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
+        const filePath = path.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        fs.writeFileSync(filePath, value);
+      } catch {}
+    }
+  };
+}
+function getPlatformConfigWithCliDefaults(userConfig, options) {
+  const basePlatformConfig = getPlatformConfig();
+  const cacheDir = options?.projectDir ? path.join(options.projectDir, ".tscircuit", "cache") : undefined;
+  const defaultConfig = {
+    ...basePlatformConfig,
+    localCacheEngine: createLocalCacheEngine(cacheDir),
+    footprintFileParserMap: {
+      ...basePlatformConfig.footprintFileParserMap,
+      kicad_mod: {
+        loadFromUrl: async (url) => {
+          let fetchUrl = url;
+          if (url.startsWith("./") || url.startsWith("../")) {
+            const absolutePath = path.resolve(process.cwd(), url);
+            fetchUrl = `file://${absolutePath}`;
+          } else if (url.startsWith("/")) {
+            if (fs.existsSync(url)) {
+              fetchUrl = `file://${url}`;
+            } else {
+              const relativePath = `.${url}`;
+              const absolutePath = path.resolve(process.cwd(), relativePath);
+              if (fs.existsSync(absolutePath)) {
+                fetchUrl = `file://${absolutePath}`;
+              } else {
+                fetchUrl = `file://${url}`;
+              }
+            }
+          }
+          return basePlatformConfig.footprintFileParserMap.kicad_mod.loadFromUrl(fetchUrl);
+        }
+      }
+    }
+  };
+  if (!userConfig) {
+    return defaultConfig;
+  }
+  const mergedConfig = {
+    ...defaultConfig,
+    ...userConfig,
+    footprintFileParserMap: {
+      ...defaultConfig.footprintFileParserMap,
+      ...userConfig.footprintFileParserMap
+    }
+  };
+  if (defaultConfig.staticFileLoaderMap || userConfig.staticFileLoaderMap) {
+    mergedConfig.staticFileLoaderMap = {
+      ...defaultConfig.staticFileLoaderMap,
+      ...userConfig.staticFileLoaderMap
+    };
+  }
+  return mergedConfig;
+}
+
 // node_modules/conf/dist/source/index.js
 import { isDeepStrictEqual } from "node:util";
 import process7 from "node:process";
-import fs2 from "node:fs";
-import path4 from "node:path";
+import fs3 from "node:fs";
+import path5 from "node:path";
 import crypto2 from "node:crypto";
 import assert from "node:assert";
 
@@ -66857,12 +66937,12 @@ var disallowedKeys = new Set([
   "constructor"
 ]);
 var digits = new Set("0123456789");
-function getPathSegments(path) {
+function getPathSegments(path2) {
   const parts = [];
   let currentSegment = "";
   let currentPart = "start";
   let isIgnoring = false;
-  for (const character of path) {
+  for (const character of path2) {
     switch (character) {
       case "\\": {
         if (currentPart === "index") {
@@ -66984,11 +67064,11 @@ function assertNotStringIndex(object, key) {
     throw new Error("Cannot use string index");
   }
 }
-function getProperty(object, path, value) {
-  if (!isObject(object) || typeof path !== "string") {
+function getProperty(object, path2, value) {
+  if (!isObject(object) || typeof path2 !== "string") {
     return value === undefined ? object : value;
   }
-  const pathArray = getPathSegments(path);
+  const pathArray = getPathSegments(path2);
   if (pathArray.length === 0) {
     return value;
   }
@@ -67008,12 +67088,12 @@ function getProperty(object, path, value) {
   }
   return object === undefined ? value : object;
 }
-function setProperty(object, path, value) {
-  if (!isObject(object) || typeof path !== "string") {
+function setProperty(object, path2, value) {
+  if (!isObject(object) || typeof path2 !== "string") {
     return object;
   }
   const root = object;
-  const pathArray = getPathSegments(path);
+  const pathArray = getPathSegments(path2);
   for (let index = 0;index < pathArray.length; index++) {
     const key = pathArray[index];
     assertNotStringIndex(object, key);
@@ -67026,11 +67106,11 @@ function setProperty(object, path, value) {
   }
   return root;
 }
-function deleteProperty(object, path) {
-  if (!isObject(object) || typeof path !== "string") {
+function deleteProperty(object, path2) {
+  if (!isObject(object) || typeof path2 !== "string") {
     return false;
   }
-  const pathArray = getPathSegments(path);
+  const pathArray = getPathSegments(path2);
   for (let index = 0;index < pathArray.length; index++) {
     const key = pathArray[index];
     assertNotStringIndex(object, key);
@@ -67044,11 +67124,11 @@ function deleteProperty(object, path) {
     }
   }
 }
-function hasProperty(object, path) {
-  if (!isObject(object) || typeof path !== "string") {
+function hasProperty(object, path2) {
+  if (!isObject(object) || typeof path2 !== "string") {
     return false;
   }
-  const pathArray = getPathSegments(path);
+  const pathArray = getPathSegments(path2);
   if (pathArray.length === 0) {
     return false;
   }
@@ -67062,41 +67142,41 @@ function hasProperty(object, path) {
 }
 
 // node_modules/env-paths/index.js
-import path from "node:path";
+import path2 from "node:path";
 import os from "node:os";
 import process2 from "node:process";
 var homedir = os.homedir();
 var tmpdir = os.tmpdir();
 var { env } = process2;
 var macos = (name) => {
-  const library = path.join(homedir, "Library");
+  const library = path2.join(homedir, "Library");
   return {
-    data: path.join(library, "Application Support", name),
-    config: path.join(library, "Preferences", name),
-    cache: path.join(library, "Caches", name),
-    log: path.join(library, "Logs", name),
-    temp: path.join(tmpdir, name)
+    data: path2.join(library, "Application Support", name),
+    config: path2.join(library, "Preferences", name),
+    cache: path2.join(library, "Caches", name),
+    log: path2.join(library, "Logs", name),
+    temp: path2.join(tmpdir, name)
   };
 };
 var windows = (name) => {
-  const appData = env.APPDATA || path.join(homedir, "AppData", "Roaming");
-  const localAppData = env.LOCALAPPDATA || path.join(homedir, "AppData", "Local");
+  const appData = env.APPDATA || path2.join(homedir, "AppData", "Roaming");
+  const localAppData = env.LOCALAPPDATA || path2.join(homedir, "AppData", "Local");
   return {
-    data: path.join(localAppData, name, "Data"),
-    config: path.join(appData, name, "Config"),
-    cache: path.join(localAppData, name, "Cache"),
-    log: path.join(localAppData, name, "Log"),
-    temp: path.join(tmpdir, name)
+    data: path2.join(localAppData, name, "Data"),
+    config: path2.join(appData, name, "Config"),
+    cache: path2.join(localAppData, name, "Cache"),
+    log: path2.join(localAppData, name, "Log"),
+    temp: path2.join(tmpdir, name)
   };
 };
 var linux = (name) => {
-  const username = path.basename(homedir);
+  const username = path2.basename(homedir);
   return {
-    data: path.join(env.XDG_DATA_HOME || path.join(homedir, ".local", "share"), name),
-    config: path.join(env.XDG_CONFIG_HOME || path.join(homedir, ".config"), name),
-    cache: path.join(env.XDG_CACHE_HOME || path.join(homedir, ".cache"), name),
-    log: path.join(env.XDG_STATE_HOME || path.join(homedir, ".local", "state"), name),
-    temp: path.join(tmpdir, username, name)
+    data: path2.join(env.XDG_DATA_HOME || path2.join(homedir, ".local", "share"), name),
+    config: path2.join(env.XDG_CONFIG_HOME || path2.join(homedir, ".config"), name),
+    cache: path2.join(env.XDG_CACHE_HOME || path2.join(homedir, ".cache"), name),
+    log: path2.join(env.XDG_STATE_HOME || path2.join(homedir, ".local", "state"), name),
+    temp: path2.join(tmpdir, username, name)
   };
 };
 function envPaths(name, { suffix = "nodejs" } = {}) {
@@ -67116,10 +67196,10 @@ function envPaths(name, { suffix = "nodejs" } = {}) {
 }
 
 // node_modules/atomically/dist/index.js
-import path3 from "node:path";
+import path4 from "node:path";
 
 // node_modules/stubborn-fs/dist/index.js
-import fs from "node:fs";
+import fs2 from "node:fs";
 import { promisify } from "node:util";
 
 // node_modules/stubborn-utils/dist/attemptify_async.js
@@ -67249,41 +67329,41 @@ var RETRYIFY_OPTIONS = {
 // node_modules/stubborn-fs/dist/index.js
 var FS = {
   attempt: {
-    chmod: attemptify_async_default(promisify(fs.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-    chown: attemptify_async_default(promisify(fs.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-    close: attemptify_async_default(promisify(fs.close), ATTEMPTIFY_NOOP_OPTIONS),
-    fsync: attemptify_async_default(promisify(fs.fsync), ATTEMPTIFY_NOOP_OPTIONS),
-    mkdir: attemptify_async_default(promisify(fs.mkdir), ATTEMPTIFY_NOOP_OPTIONS),
-    realpath: attemptify_async_default(promisify(fs.realpath), ATTEMPTIFY_NOOP_OPTIONS),
-    stat: attemptify_async_default(promisify(fs.stat), ATTEMPTIFY_NOOP_OPTIONS),
-    unlink: attemptify_async_default(promisify(fs.unlink), ATTEMPTIFY_NOOP_OPTIONS),
-    chmodSync: attemptify_sync_default(fs.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-    chownSync: attemptify_sync_default(fs.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-    closeSync: attemptify_sync_default(fs.closeSync, ATTEMPTIFY_NOOP_OPTIONS),
-    existsSync: attemptify_sync_default(fs.existsSync, ATTEMPTIFY_NOOP_OPTIONS),
-    fsyncSync: attemptify_sync_default(fs.fsync, ATTEMPTIFY_NOOP_OPTIONS),
-    mkdirSync: attemptify_sync_default(fs.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS),
-    realpathSync: attemptify_sync_default(fs.realpathSync, ATTEMPTIFY_NOOP_OPTIONS),
-    statSync: attemptify_sync_default(fs.statSync, ATTEMPTIFY_NOOP_OPTIONS),
-    unlinkSync: attemptify_sync_default(fs.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS)
+    chmod: attemptify_async_default(promisify(fs2.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    chown: attemptify_async_default(promisify(fs2.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    close: attemptify_async_default(promisify(fs2.close), ATTEMPTIFY_NOOP_OPTIONS),
+    fsync: attemptify_async_default(promisify(fs2.fsync), ATTEMPTIFY_NOOP_OPTIONS),
+    mkdir: attemptify_async_default(promisify(fs2.mkdir), ATTEMPTIFY_NOOP_OPTIONS),
+    realpath: attemptify_async_default(promisify(fs2.realpath), ATTEMPTIFY_NOOP_OPTIONS),
+    stat: attemptify_async_default(promisify(fs2.stat), ATTEMPTIFY_NOOP_OPTIONS),
+    unlink: attemptify_async_default(promisify(fs2.unlink), ATTEMPTIFY_NOOP_OPTIONS),
+    chmodSync: attemptify_sync_default(fs2.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    chownSync: attemptify_sync_default(fs2.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    closeSync: attemptify_sync_default(fs2.closeSync, ATTEMPTIFY_NOOP_OPTIONS),
+    existsSync: attemptify_sync_default(fs2.existsSync, ATTEMPTIFY_NOOP_OPTIONS),
+    fsyncSync: attemptify_sync_default(fs2.fsync, ATTEMPTIFY_NOOP_OPTIONS),
+    mkdirSync: attemptify_sync_default(fs2.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS),
+    realpathSync: attemptify_sync_default(fs2.realpathSync, ATTEMPTIFY_NOOP_OPTIONS),
+    statSync: attemptify_sync_default(fs2.statSync, ATTEMPTIFY_NOOP_OPTIONS),
+    unlinkSync: attemptify_sync_default(fs2.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS)
   },
   retry: {
-    close: retryify_async_default(promisify(fs.close), RETRYIFY_OPTIONS),
-    fsync: retryify_async_default(promisify(fs.fsync), RETRYIFY_OPTIONS),
-    open: retryify_async_default(promisify(fs.open), RETRYIFY_OPTIONS),
-    readFile: retryify_async_default(promisify(fs.readFile), RETRYIFY_OPTIONS),
-    rename: retryify_async_default(promisify(fs.rename), RETRYIFY_OPTIONS),
-    stat: retryify_async_default(promisify(fs.stat), RETRYIFY_OPTIONS),
-    write: retryify_async_default(promisify(fs.write), RETRYIFY_OPTIONS),
-    writeFile: retryify_async_default(promisify(fs.writeFile), RETRYIFY_OPTIONS),
-    closeSync: retryify_sync_default(fs.closeSync, RETRYIFY_OPTIONS),
-    fsyncSync: retryify_sync_default(fs.fsyncSync, RETRYIFY_OPTIONS),
-    openSync: retryify_sync_default(fs.openSync, RETRYIFY_OPTIONS),
-    readFileSync: retryify_sync_default(fs.readFileSync, RETRYIFY_OPTIONS),
-    renameSync: retryify_sync_default(fs.renameSync, RETRYIFY_OPTIONS),
-    statSync: retryify_sync_default(fs.statSync, RETRYIFY_OPTIONS),
-    writeSync: retryify_sync_default(fs.writeSync, RETRYIFY_OPTIONS),
-    writeFileSync: retryify_sync_default(fs.writeFileSync, RETRYIFY_OPTIONS)
+    close: retryify_async_default(promisify(fs2.close), RETRYIFY_OPTIONS),
+    fsync: retryify_async_default(promisify(fs2.fsync), RETRYIFY_OPTIONS),
+    open: retryify_async_default(promisify(fs2.open), RETRYIFY_OPTIONS),
+    readFile: retryify_async_default(promisify(fs2.readFile), RETRYIFY_OPTIONS),
+    rename: retryify_async_default(promisify(fs2.rename), RETRYIFY_OPTIONS),
+    stat: retryify_async_default(promisify(fs2.stat), RETRYIFY_OPTIONS),
+    write: retryify_async_default(promisify(fs2.write), RETRYIFY_OPTIONS),
+    writeFile: retryify_async_default(promisify(fs2.writeFile), RETRYIFY_OPTIONS),
+    closeSync: retryify_sync_default(fs2.closeSync, RETRYIFY_OPTIONS),
+    fsyncSync: retryify_sync_default(fs2.fsyncSync, RETRYIFY_OPTIONS),
+    openSync: retryify_sync_default(fs2.openSync, RETRYIFY_OPTIONS),
+    readFileSync: retryify_sync_default(fs2.readFileSync, RETRYIFY_OPTIONS),
+    renameSync: retryify_sync_default(fs2.renameSync, RETRYIFY_OPTIONS),
+    statSync: retryify_sync_default(fs2.statSync, RETRYIFY_OPTIONS),
+    writeSync: retryify_sync_default(fs2.writeSync, RETRYIFY_OPTIONS),
+    writeFileSync: retryify_sync_default(fs2.writeFileSync, RETRYIFY_OPTIONS)
   }
 };
 var dist_default = FS;
@@ -67313,7 +67393,7 @@ var isUndefined = (value) => {
 };
 
 // node_modules/atomically/dist/utils/temp.js
-import path2 from "node:path";
+import path3 from "node:path";
 
 // node_modules/when-exit/dist/node/interceptor.js
 import process6 from "node:process";
@@ -67413,7 +67493,7 @@ var Temp = {
     }
   },
   truncate: (filePath) => {
-    const basename = path2.basename(filePath);
+    const basename = path3.basename(filePath);
     if (basename.length <= LIMIT_BASENAME_LENGTH)
       return filePath;
     const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename);
@@ -67455,7 +67535,7 @@ function writeFileSync(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
       }
     }
     if (!filePathExists) {
-      const parentPath = path3.dirname(filePath);
+      const parentPath = path4.dirname(filePath);
       dist_default.attempt.mkdirSync(parentPath, {
         mode: DEFAULT_FOLDER_MODE,
         recursive: true
@@ -67771,7 +67851,7 @@ class Conf {
     this.events = new EventTarget;
     this.#encryptionKey = options.encryptionKey;
     const fileExtension = options.fileExtension ? `.${options.fileExtension}` : "";
-    this.path = path4.resolve(options.cwd, `${options.configName ?? "config"}${fileExtension}`);
+    this.path = path5.resolve(options.cwd, `${options.configName ?? "config"}${fileExtension}`);
     const fileStore = this.store;
     const store = Object.assign(createPlainObject(), options.defaults, fileStore);
     if (options.migrations) {
@@ -67874,7 +67954,7 @@ class Conf {
   }
   get store() {
     try {
-      const data = fs2.readFileSync(this.path, this.#encryptionKey ? null : "utf8");
+      const data = fs3.readFileSync(this.path, this.#encryptionKey ? null : "utf8");
       const dataString = this._encryptData(data);
       const deserializedData = this._deserialize(dataString);
       this._validate(deserializedData);
@@ -67945,7 +68025,7 @@ class Conf {
     throw new Error("Config schema violation: " + errors.join("; "));
   }
   _ensureDirectory() {
-    fs2.mkdirSync(path4.dirname(this.path), { recursive: true });
+    fs3.mkdirSync(path5.dirname(this.path), { recursive: true });
   }
   _write(value) {
     let data = this._serialize(value);
@@ -67956,13 +68036,13 @@ class Conf {
       data = concatUint8Arrays([initializationVector, stringToUint8Array(":"), cipher.update(stringToUint8Array(data)), cipher.final()]);
     }
     if (process7.env.SNAP) {
-      fs2.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
+      fs3.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
     } else {
       try {
         writeFileSync(this.path, data, { mode: this.#options.configFileMode });
       } catch (error) {
         if (error?.code === "EXDEV") {
-          fs2.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
+          fs3.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
           return;
         }
         throw error;
@@ -67971,15 +68051,15 @@ class Conf {
   }
   _watch() {
     this._ensureDirectory();
-    if (!fs2.existsSync(this.path)) {
+    if (!fs3.existsSync(this.path)) {
       this._write(createPlainObject());
     }
     if (process7.platform === "win32") {
-      fs2.watch(this.path, { persistent: false }, debounce_fn_default(() => {
+      fs3.watch(this.path, { persistent: false }, debounce_fn_default(() => {
         this.events.dispatchEvent(new Event("change"));
       }, { wait: 100 }));
     } else {
-      fs2.watchFile(this.path, { persistent: false }, debounce_fn_default(() => {
+      fs3.watchFile(this.path, { persistent: false }, debounce_fn_default(() => {
         this.events.dispatchEvent(new Event("change"));
       }, { wait: 5000 }));
     }
@@ -68115,14 +68195,14 @@ function jwtDecode(token, options) {
 }
 
 // lib/cli-config/index.ts
-import fs4 from "node:fs";
+import fs5 from "node:fs";
 import os3 from "node:os";
-import path6 from "node:path";
+import path7 from "node:path";
 
 // lib/shared/handle-registry-auth-error.ts
-import fs3 from "node:fs";
+import fs4 from "node:fs";
 import os2 from "node:os";
-import path5 from "node:path";
+import path6 from "node:path";
 
 // node_modules/kleur/index.mjs
 var FORCE_COLOR;
@@ -68242,9 +68322,9 @@ function isUnauthorizedError(error) {
   return /\b(401|E401)\b/i.test(output) || /unauthorized/i.test(output);
 }
 function hasTsciAuthToken(npmrcPath) {
-  if (!fs3.existsSync(npmrcPath))
+  if (!fs4.existsSync(npmrcPath))
     return false;
-  const content = fs3.readFileSync(npmrcPath, "utf-8");
+  const content = fs4.readFileSync(npmrcPath, "utf-8");
   return AUTH_TOKEN_REGEX.test(content);
 }
 function handleRegistryAuthError({
@@ -68254,8 +68334,8 @@ function handleRegistryAuthError({
   if (!isUnauthorizedError(error))
     return;
   const npmrcPaths = [
-    path5.join(projectDir, ".npmrc"),
-    path5.join(os2.homedir(), ".npmrc")
+    path6.join(projectDir, ".npmrc"),
+    path6.join(os2.homedir(), ".npmrc")
   ];
   const hasToken = npmrcPaths.some(hasTsciAuthToken);
   if (hasToken) {
@@ -68278,13 +68358,13 @@ var getSessionToken = () => {
 };
 var getSessionTokenFromNpmrc = () => {
   const npmrcPaths = [
-    path6.join(process.cwd(), ".npmrc"),
-    path6.join(os3.homedir(), ".npmrc")
+    path7.join(process.cwd(), ".npmrc"),
+    path7.join(os3.homedir(), ".npmrc")
   ];
   for (const npmrcPath of npmrcPaths) {
-    if (!fs4.existsSync(npmrcPath))
+    if (!fs5.existsSync(npmrcPath))
       continue;
-    const content = fs4.readFileSync(npmrcPath, "utf-8");
+    const content = fs5.readFileSync(npmrcPath, "utf-8");
     const match = content.match(AUTH_TOKEN_REGEX);
     if (match?.[1]) {
       return match[1].trim();
@@ -69579,13 +69659,13 @@ function buildSymbolDataFromSchematicPrimitives(params2) {
       ]
     });
   }
-  for (const path7 of paths) {
-    if (path7.points && path7.points.length > 0) {
+  for (const path8 of paths) {
+    if (path8.points && path8.points.length > 0) {
       primitives2.push({
         type: "path",
-        points: path7.points,
-        fill: path7.is_filled ?? false,
-        fillColor: path7.fill_color
+        points: path8.points,
+        fill: path8.is_filled ?? false,
+        fillColor: path8.fill_color
       });
     }
   }
@@ -70454,10 +70534,10 @@ var AddSchematicNetLabelsStage = class extends ConverterStage {
     const instances = new SymbolInstances;
     const project = new SymbolInstancesProject("");
     const instancePathPrefix = this.ctx.symbolInstancePathPrefix ?? `/${kicadSch?.uuid?.value || ""}`;
-    const path7 = new SymbolInstancePath(instancePathPrefix);
-    path7.reference = labelText;
-    path7.unit = 1;
-    project.paths.push(path7);
+    const path8 = new SymbolInstancePath(instancePathPrefix);
+    path8.reference = labelText;
+    path8.unit = 1;
+    project.paths.push(path8);
     instances.projects.push(project);
     symbol._sxInstances = instances;
     return symbol;
@@ -70702,10 +70782,10 @@ var AddSchematicSymbolsStage = class extends ConverterStage {
       const instances = new SymbolInstances2;
       const project = new SymbolInstancesProject2("");
       const instancePathPrefix = this.ctx.symbolInstancePathPrefix ?? `/${kicadSch?.uuid?.value || ""}`;
-      const path7 = new SymbolInstancePath2(instancePathPrefix);
-      path7.reference = reference;
-      path7.unit = 1;
-      project.paths.push(path7);
+      const path8 = new SymbolInstancePath2(instancePathPrefix);
+      path8.reference = reference;
+      path8.unit = 1;
+      project.paths.push(path8);
       instances.projects.push(project);
       symbol._sxInstances = instances;
       symbols4.push(symbol);
@@ -70974,11 +71054,11 @@ var AddSheetInstancesStage = class extends ConverterStage {
       throw new Error("KicadSch instance not initialized in context");
     }
     const sheetInstances = new SheetInstances;
-    const path7 = new SheetInstancesRootPath;
-    path7.value = "/";
+    const path8 = new SheetInstancesRootPath;
+    path8.value = "/";
     const page = new SheetInstancesRootPage("1");
-    path7.pages = [page];
-    sheetInstances.paths = [path7];
+    path8.pages = [page];
+    sheetInstances.paths = [path8];
     kicadSch.sheetInstances = sheetInstances;
     kicadSch.embeddedFonts = new EmbeddedFonts3(false);
     this.finished = true;
@@ -72200,17 +72280,17 @@ function convertSilkscreenTexts(params2) {
 function convertSilkscreenPaths(silkscreenPaths, { componentCenter, componentRotation = 0 }) {
   const fpLines = [];
   const rotationMatrix = componentRotation !== 0 ? rotate4(componentRotation * Math.PI / 180) : identity2();
-  for (const path7 of silkscreenPaths) {
-    if (!path7.route || path7.route.length < 2)
+  for (const path8 of silkscreenPaths) {
+    if (!path8.route || path8.route.length < 2)
       continue;
     const layerMap = {
       top: "F.SilkS",
       bottom: "B.SilkS"
     };
-    const kicadLayer = layerMap[path7.layer] || path7.layer || "F.SilkS";
-    for (let i = 0;i < path7.route.length - 1; i++) {
-      const startPoint = path7.route[i];
-      const endPoint = path7.route[i + 1];
+    const kicadLayer = layerMap[path8.layer] || path8.layer || "F.SilkS";
+    for (let i = 0;i < path8.route.length - 1; i++) {
+      const startPoint = path8.route[i];
+      const endPoint = path8.route[i + 1];
       if (!startPoint || !endPoint)
         continue;
       const startRelative = applyToPoint12(rotationMatrix, {
@@ -72228,7 +72308,7 @@ function convertSilkscreenPaths(silkscreenPaths, { componentCenter, componentRot
         stroke: new Stroke12
       });
       if (fpLine.stroke) {
-        fpLine.stroke.width = path7.stroke_width || 0.15;
+        fpLine.stroke.width = path8.stroke_width || 0.15;
         fpLine.stroke.type = "default";
       }
       fpLines.push(fpLine);
@@ -72721,7 +72801,7 @@ var AddFootprintsStage = class extends ConverterStage {
       componentRotation: component.rotation || 0
     }));
     footprint.fpTexts = fpTexts;
-    const pcbSilkscreenPaths = this.ctx.db.pcb_silkscreen_path?.list().filter((path7) => path7.pcb_component_id === component.pcb_component_id) || [];
+    const pcbSilkscreenPaths = this.ctx.db.pcb_silkscreen_path?.list().filter((path8) => path8.pcb_component_id === component.pcb_component_id) || [];
     const fpLines = footprint.fpLines ?? [];
     fpLines.push(...convertSilkscreenPaths(pcbSilkscreenPaths, {
       componentCenter: component.center,
@@ -73438,13 +73518,13 @@ var AddGraphicsStage = class extends ConverterStage {
     if (!c2kMatPcb) {
       throw new Error("PCB transformation matrix not initialized in context");
     }
-    const pcbSilkscreenPaths = this.ctx.db.pcb_silkscreen_path?.list().filter((path7) => !path7.pcb_component_id) || [];
-    for (const path7 of pcbSilkscreenPaths) {
-      if (!path7.route || path7.route.length < 2)
+    const pcbSilkscreenPaths = this.ctx.db.pcb_silkscreen_path?.list().filter((path8) => !path8.pcb_component_id) || [];
+    for (const path8 of pcbSilkscreenPaths) {
+      if (!path8.route || path8.route.length < 2)
         continue;
-      for (let i = 0;i < path7.route.length - 1; i++) {
-        const startPoint = path7.route[i];
-        const endPoint = path7.route[i + 1];
+      for (let i = 0;i < path8.route.length - 1; i++) {
+        const startPoint = path8.route[i];
+        const endPoint = path8.route[i + 1];
         if (!startPoint || !endPoint)
           continue;
         const transformedStart = applyToPoint23(c2kMatPcb, {
@@ -73459,12 +73539,12 @@ var AddGraphicsStage = class extends ConverterStage {
           top: "F.SilkS",
           bottom: "B.SilkS"
         };
-        const kicadLayer = layerMap[path7.layer] || path7.layer || "F.SilkS";
+        const kicadLayer = layerMap[path8.layer] || path8.layer || "F.SilkS";
         const grLine = new GrLine({
           start: { x: transformedStart.x, y: transformedStart.y },
           end: { x: transformedEnd.x, y: transformedEnd.y },
           layer: kicadLayer,
-          width: path7.stroke_width || 0.15
+          width: path8.stroke_width || 0.15
         });
         appendGraphicLine(kicadPcb, grLine);
       }
@@ -74784,9 +74864,9 @@ var KicadLibraryConverter = class {
       });
       libConverter.runUntilFinished();
       const libOutput = libConverter.getOutput();
-      for (const path7 of libOutput.model3dSourcePaths) {
-        if (!this.ctx.model3dSourcePaths.includes(path7)) {
-          this.ctx.model3dSourcePaths.push(path7);
+      for (const path8 of libOutput.model3dSourcePaths) {
+        if (!this.ctx.model3dSourcePaths.includes(path8)) {
+          this.ctx.model3dSourcePaths.push(path8);
         }
       }
       extractedKicadComponents.push({
@@ -74828,12 +74908,12 @@ function deriveComponentNameFromPath(filePath) {
 
 // lib/shared/importFromUserLand.ts
 import { createRequire as createRequire2 } from "node:module";
-import fs5 from "node:fs";
-import path7 from "node:path";
+import fs6 from "node:fs";
+import path8 from "node:path";
 async function importFromUserLand(moduleName) {
-  const userModulePath = path7.join(process.cwd(), "node_modules", moduleName);
-  if (fs5.existsSync(userModulePath)) {
-    const userRequire = createRequire2(path7.join(process.cwd(), "noop.js"));
+  const userModulePath = path8.join(process.cwd(), "node_modules", moduleName);
+  if (fs6.existsSync(userModulePath)) {
+    const userRequire = createRequire2(path8.join(process.cwd(), "noop.js"));
     try {
       const resolvedUserPath = userRequire.resolve(moduleName);
       return await import(resolvedUserPath);
@@ -74855,85 +74935,6 @@ async function importFromUserLand(moduleName) {
   return import(moduleName);
 }
 
-// lib/shared/get-platform-config-with-cli-defaults.ts
-import { createHash } from "node:crypto";
-import fs6 from "node:fs";
-import path8 from "node:path";
-import { getPlatformConfig } from "@tscircuit/eval/platform-config";
-function createLocalCacheEngine(cacheDir = path8.join(process.cwd(), ".tscircuit", "cache")) {
-  return {
-    getItem: (key) => {
-      try {
-        const hash = createHash("md5").update(key).digest("hex");
-        const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
-        const filePath = path8.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
-        return fs6.readFileSync(filePath, "utf-8");
-      } catch {
-        return null;
-      }
-    },
-    setItem: (key, value) => {
-      try {
-        fs6.mkdirSync(cacheDir, { recursive: true });
-        const hash = createHash("md5").update(key).digest("hex");
-        const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
-        const filePath = path8.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
-        fs6.writeFileSync(filePath, value);
-      } catch {}
-    }
-  };
-}
-function getPlatformConfigWithCliDefaults(userConfig) {
-  const basePlatformConfig = getPlatformConfig();
-  const defaultConfig = {
-    ...basePlatformConfig,
-    localCacheEngine: createLocalCacheEngine(),
-    footprintFileParserMap: {
-      ...basePlatformConfig.footprintFileParserMap,
-      kicad_mod: {
-        loadFromUrl: async (url) => {
-          let fetchUrl = url;
-          if (url.startsWith("./") || url.startsWith("../")) {
-            const absolutePath = path8.resolve(process.cwd(), url);
-            fetchUrl = `file://${absolutePath}`;
-          } else if (url.startsWith("/")) {
-            if (fs6.existsSync(url)) {
-              fetchUrl = `file://${url}`;
-            } else {
-              const relativePath = `.${url}`;
-              const absolutePath = path8.resolve(process.cwd(), relativePath);
-              if (fs6.existsSync(absolutePath)) {
-                fetchUrl = `file://${absolutePath}`;
-              } else {
-                fetchUrl = `file://${url}`;
-              }
-            }
-          }
-          return basePlatformConfig.footprintFileParserMap.kicad_mod.loadFromUrl(fetchUrl);
-        }
-      }
-    }
-  };
-  if (!userConfig) {
-    return defaultConfig;
-  }
-  const mergedConfig = {
-    ...defaultConfig,
-    ...userConfig,
-    footprintFileParserMap: {
-      ...defaultConfig.footprintFileParserMap,
-      ...userConfig.footprintFileParserMap
-    }
-  };
-  if (defaultConfig.staticFileLoaderMap || userConfig.staticFileLoaderMap) {
-    mergedConfig.staticFileLoaderMap = {
-      ...defaultConfig.staticFileLoaderMap,
-      ...userConfig.staticFileLoaderMap
-    };
-  }
-  return mergedConfig;
-}
-
 // lib/shared/convert-to-kicad-library.tsx
 import { jsxDEV } from "react/jsx-dev-runtime";
 async function convertToKicadLibrary({
@@ -76189,17 +76190,25 @@ Rebuilding KiCad PCM assets...`));
 };
 
 // lib/server/createHttpServer.ts
+var RUNFRAME_CACHE_PATH = "/api/cache";
 var resolveLocalTscircuitStandalonePath = (projectDir) => {
   if (!projectDir)
     return;
   try {
     const projectRequire = createRequire3(path16.join(projectDir, "package.json"));
-    const browserBundlePath = path16.join(path16.dirname(projectRequire.resolve("tscircuit/package.json")), "dist", "browser.min.js");
+    const browserBundlePath = projectRequire.resolve("tscircuit/browser");
     if (fs16.existsSync(browserBundlePath))
       return browserBundlePath;
   } catch {}
   return;
 };
+var readRequestBody = async (req) => {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+};
 var createHttpServer = async ({
   port = 3020,
   defaultMainComponentPath,
@@ -76208,10 +76217,42 @@ var createHttpServer = async ({
   entryFile
 }) => {
   const fileServerHandler = getNodeHandler(stdin_default, {});
+  const localCacheEngine = projectDir ? createLocalCacheEngine(path16.join(projectDir, ".tscircuit", "cache")) : undefined;
   const pcmProxy = kicadPcm && projectDir && entryFile ? createKicadPcmProxy({ projectDir, entryFile, port }) : null;
   const server = http.createServer(async (req, res) => {
     const requestHost = req.headers.host ?? `localhost:${port}`;
     const url = new URL(req.url, `http://${requestHost}`);
+    if (url.pathname === RUNFRAME_CACHE_PATH) {
+      const key = url.searchParams.get("key");
+      if (!localCacheEngine || !key) {
+        res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
+        res.end("A project directory and cache key are required");
+        return;
+      }
+      if (req.method === "GET") {
+        const value = await localCacheEngine.getItem(key);
+        if (value === null) {
+          res.writeHead(404);
+          res.end();
+          return;
+        }
+        res.writeHead(200, {
+          "Content-Type": "text/plain; charset=utf-8",
+          "Cache-Control": "no-store"
+        });
+        res.end(value);
+        return;
+      }
+      if (req.method === "POST") {
+        await localCacheEngine.setItem(key, await readRequestBody(req));
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+      res.writeHead(405, { Allow: "GET, POST" });
+      res.end();
+      return;
+    }
     if (url.pathname === "/api/files/upsert-multipart" && req.method === "POST") {
       try {
         const request = new Request(url.toString(), {
@@ -77045,9 +77086,9 @@ class NodeFsHandler {
     if (this.fsw.closed) {
       return;
     }
-    const dirname3 = sysPath.dirname(file);
+    const dirname2 = sysPath.dirname(file);
     const basename2 = sysPath.basename(file);
-    const parent = this.fsw._getWatchedDir(dirname3);
+    const parent = this.fsw._getWatchedDir(dirname2);
     let prevStats = stats;
     if (parent.has(basename2))
       return;
@@ -77074,7 +77115,7 @@ class NodeFsHandler {
             prevStats = newStats2;
           }
         } catch (error) {
-          this.fsw._remove(dirname3, basename2);
+          this.fsw._remove(dirname2, basename2);
         }
       } else if (parent.has(basename2)) {
         const at = newStats.atimeMs;