@swarm.ing/pieui 3.0.0 → 3.0.2

package/dist/cli.js

@@ -196293,7 +196293,7 @@ var postbuildCommand = async (srcDir, outDir, append) => {
 };
 
 // src/code/commands/cardRemote/push.ts
-var import_node_fs7 = __toESM(require("node:fs"));
+var import_node_fs8 = __toESM(require("node:fs"));
 var import_node_path9 = __toESM(require("node:path"));
 
 // src/code/services/settings.ts
@@ -196833,7 +196833,7 @@ ${detail}` : `${opts.method} ${opts.url} failed: ${response.status}`;
 }
 
 // src/code/commands/cardDumpMetadata.ts
-var import_node_fs6 = __toESM(require("node:fs"));
+var import_node_fs7 = __toESM(require("node:fs"));
 var import_node_path8 = __toESM(require("node:path"));
 
 // src/code/introspection/errors.ts
@@ -196911,6 +196911,7 @@ var errorOptsFromNode = (sourceFile, node) => ({
 });
 
 // src/code/introspection/schemaContext.ts
+var import_node_fs4 = __toESM(require("node:fs"));
 var import_node_path5 = __toESM(require("node:path"));
 var __dirname = "/home/runner/work/pieui/pieui/src/code/introspection";
 var DEFAULT_COMPILER_OPTIONS = () => ({
@@ -196923,10 +196924,43 @@ var DEFAULT_COMPILER_OPTIONS = () => ({
   allowSyntheticDefaultImports: true,
   skipLibCheck: true
 });
+var findTsconfig = (fromDir) => {
+  let dir = import_node_path5.default.resolve(fromDir);
+  for (;; ) {
+    const candidate = import_node_path5.default.join(dir, "tsconfig.json");
+    if (import_node_fs4.default.existsSync(candidate))
+      return candidate;
+    const parent = import_node_path5.default.dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+};
+var loadPathAliases = (files) => {
+  const seed = files.find((f) => !f.endsWith(".d.ts")) ?? files[0];
+  if (!seed)
+    return {};
+  const tsconfigPath = findTsconfig(import_node_path5.default.dirname(import_node_path5.default.resolve(seed)));
+  if (!tsconfigPath)
+    return {};
+  const configDir = import_node_path5.default.dirname(tsconfigPath);
+  const read = ts2.readConfigFile(tsconfigPath, ts2.sys.readFile);
+  if (read.error || !read.config)
+    return {};
+  const parsed = ts2.parseJsonConfigFileContent(read.config, ts2.sys, configDir);
+  const options = parsed.options ?? {};
+  if (!options.paths && !options.baseUrl)
+    return {};
+  return { baseUrl: options.baseUrl ?? configDir, paths: options.paths };
+};
 var createSchemaContext = (files) => {
   const cliSchemaPath = import_node_path5.default.join(__dirname, "..", "commands", "cli-schema.d.ts");
   const uniqueFiles = Array.from(new Set([cliSchemaPath, ...files]));
-  const program = TJS.getProgramFromFiles(uniqueFiles, DEFAULT_COMPILER_OPTIONS());
+  const compilerOptions = {
+    ...DEFAULT_COMPILER_OPTIONS(),
+    ...loadPathAliases(files)
+  };
+  const program = TJS.getProgramFromFiles(uniqueFiles, compilerOptions);
   const checker = program.getTypeChecker();
   const generator = TJS.buildGenerator(program, {
     required: true,
@@ -197135,23 +197169,23 @@ var collectComponentFiles = (componentDir) => {
   return Array.from(out).sort();
 };
 // src/code/introspection/extractImports.ts
-var import_node_fs4 = __toESM(require("node:fs"));
+var import_node_fs5 = __toESM(require("node:fs"));
 var import_node_path7 = __toESM(require("node:path"));
 var createHost = (cwd) => {
   const sys = ts2.sys;
   return {
-    fileExists: (name) => sys ? sys.fileExists(name) : import_node_fs4.default.existsSync(name),
+    fileExists: (name) => sys ? sys.fileExists(name) : import_node_fs5.default.existsSync(name),
     readFile: (name) => {
       if (sys)
         return sys.readFile(name);
       try {
-        return import_node_fs4.default.readFileSync(name, "utf8");
+        return import_node_fs5.default.readFileSync(name, "utf8");
       } catch {
         return;
       }
     },
-    directoryExists: (name) => sys ? sys.directoryExists(name) : import_node_fs4.default.existsSync(name) && import_node_fs4.default.statSync(name).isDirectory(),
-    getDirectories: (name) => sys ? sys.getDirectories(name) : import_node_fs4.default.existsSync(name) ? import_node_fs4.default.readdirSync(name, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name) : [],
+    directoryExists: (name) => sys ? sys.directoryExists(name) : import_node_fs5.default.existsSync(name) && import_node_fs5.default.statSync(name).isDirectory(),
+    getDirectories: (name) => sys ? sys.getDirectories(name) : import_node_fs5.default.existsSync(name) ? import_node_fs5.default.readdirSync(name, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name) : [],
     getCurrentDirectory: () => cwd,
     useCaseSensitiveFileNames: sys ? sys.useCaseSensitiveFileNames : true,
     realpath: sys?.realpath
@@ -197159,10 +197193,10 @@ var createHost = (cwd) => {
 };
 var readTsconfig = (cwd) => {
   const tsconfigPath = import_node_path7.default.join(cwd, "tsconfig.json");
-  if (!import_node_fs4.default.existsSync(tsconfigPath))
+  if (!import_node_fs5.default.existsSync(tsconfigPath))
     return {};
   try {
-    const raw = import_node_fs4.default.readFileSync(tsconfigPath, "utf8");
+    const raw = import_node_fs5.default.readFileSync(tsconfigPath, "utf8");
     const result = ts2.parseConfigFileTextToJson(tsconfigPath, raw);
     const parsed = result?.config;
     if (!parsed)
@@ -197214,13 +197248,13 @@ var tryExtensions = (candidate) => {
   const exts = ["", ".ts", ".tsx", ".d.ts", ".js", ".jsx"];
   for (const ext of exts) {
     const file = candidate + ext;
-    if (import_node_fs4.default.existsSync(file) && import_node_fs4.default.statSync(file).isFile())
+    if (import_node_fs5.default.existsSync(file) && import_node_fs5.default.statSync(file).isFile())
       return file;
   }
-  if (import_node_fs4.default.existsSync(candidate) && import_node_fs4.default.statSync(candidate).isDirectory()) {
+  if (import_node_fs5.default.existsSync(candidate) && import_node_fs5.default.statSync(candidate).isDirectory()) {
     for (const ext of ["index.ts", "index.tsx", "index.js"]) {
       const file = import_node_path7.default.join(candidate, ext);
-      if (import_node_fs4.default.existsSync(file))
+      if (import_node_fs5.default.existsSync(file))
         return file;
     }
   }
@@ -197263,10 +197297,10 @@ var isInside = (child, parent) => {
 var isNodeModulesPath = (file) => file.includes(`${import_node_path7.default.sep}node_modules${import_node_path7.default.sep}`);
 var readPackageDeps = (cwd) => {
   const pkgPath = import_node_path7.default.join(cwd, "package.json");
-  if (!import_node_fs4.default.existsSync(pkgPath))
+  if (!import_node_fs5.default.existsSync(pkgPath))
     return {};
   try {
-    const raw = import_node_fs4.default.readFileSync(pkgPath, "utf8");
+    const raw = import_node_fs5.default.readFileSync(pkgPath, "utf8");
     const pkg = JSON.parse(raw);
     return {
       ...pkg.dependencies,
@@ -197333,7 +197367,7 @@ var extractImports = (files, cwd = process.cwd()) => {
   };
 };
 // src/code/introspection/extractEvents.ts
-var import_node_fs5 = __toESM(require("node:fs"));
+var import_node_fs6 = __toESM(require("node:fs"));
 var PIE_CARD_TAG = "PieCard";
 var METHODS_PROP = "methods";
 var isPieCardJsx = (node) => {
@@ -197400,7 +197434,7 @@ var extractEvents = (files) => {
   for (const file of files) {
     let text;
     try {
-      text = import_node_fs5.default.readFileSync(file, "utf8");
+      text = import_node_fs6.default.readFileSync(file, "utf8");
     } catch {
       continue;
     }
@@ -197907,7 +197941,7 @@ var stableStringify = (value2) => {
 var buildCardMetadata = (componentName) => {
   const settings = loadSettings();
   const componentDir = import_node_path8.default.join(settings.componentsDir, componentName);
-  if (!import_node_fs6.default.existsSync(componentDir)) {
+  if (!import_node_fs7.default.existsSync(componentDir)) {
     throw new Error(`Component directory not found: ${componentDir}`);
   }
   const files = collectComponentFiles(componentDir);
@@ -197919,7 +197953,7 @@ var buildCardMetadata = (componentName) => {
   const componentsDir = settings.componentsDir;
   const fileEntries = files.map((absPath) => ({
     path: import_node_path8.default.relative(componentsDir, absPath),
-    content: import_node_fs6.default.readFileSync(absPath, "utf8")
+    content: import_node_fs7.default.readFileSync(absPath, "utf8")
   }));
   const dataType = findComponentDataTypeForName(ctx, componentName);
   const propsCode = dataType.declaration.getText();
@@ -197961,11 +197995,11 @@ var buildCardMetadata = (componentName) => {
 };
 var DUMP_METADATA_ENVELOPE_KEY = "typescript";
 var mergeEnvelopeIntoFile = (target, envelope) => {
-  if (!import_node_fs6.default.existsSync(target))
+  if (!import_node_fs7.default.existsSync(target))
     return envelope;
   let existing;
   try {
-    existing = JSON.parse(import_node_fs6.default.readFileSync(target, "utf8"));
+    existing = JSON.parse(import_node_fs7.default.readFileSync(target, "utf8"));
   } catch (e) {
     throw new Error(`[pieui] Cannot merge: existing file ${target} is not valid JSON ` + `(${e.message})`);
   }
@@ -197983,8 +198017,8 @@ var cardDumpMetadataCommand = (componentName, outFile) => {
     const resolved = import_node_path8.default.resolve(process.cwd(), outFile);
     const merged = mergeEnvelopeIntoFile(resolved, envelope);
     const json = stableStringify(merged);
-    import_node_fs6.default.mkdirSync(import_node_path8.default.dirname(resolved), { recursive: true });
-    import_node_fs6.default.writeFileSync(resolved, json, "utf8");
+    import_node_fs7.default.mkdirSync(import_node_path8.default.dirname(resolved), { recursive: true });
+    import_node_fs7.default.writeFileSync(resolved, json, "utf8");
     console.log(`[pieui] Wrote metadata: ${resolved}`);
   } else {
     process.stdout.write(stableStringify(envelope));
@@ -198066,7 +198100,7 @@ var cardRemotePushCommand = async (cardRef) => {
     throw new Error("user_id is required (set PIE_USER_ID in env or .env; run `pieui login`)");
   }
   const componentDir = import_node_path9.default.join(settings.componentsDir, componentName);
-  if (!import_node_fs7.default.existsSync(componentDir) || !import_node_fs7.default.statSync(componentDir).isDirectory()) {
+  if (!import_node_fs8.default.existsSync(componentDir) || !import_node_fs8.default.statSync(componentDir).isDirectory()) {
     throw new Error(`Component directory not found: ${componentDir}`);
   }
   const meta = buildCardMetadata(componentName);
@@ -198097,11 +198131,11 @@ var latestRevisionNumber = async (service, componentName) => {
 };
 
 // src/code/commands/cardRemote/pull.ts
-var import_node_fs9 = __toESM(require("node:fs"));
+var import_node_fs10 = __toESM(require("node:fs"));
 var import_node_path11 = __toESM(require("node:path"));
 
 // src/code/services/dumpEnvelope.ts
-var import_node_fs8 = __toESM(require("node:fs"));
+var import_node_fs9 = __toESM(require("node:fs"));
 var import_node_path10 = __toESM(require("node:path"));
 var unwrapTypescriptEnvelope = (parsed) => {
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
@@ -198139,15 +198173,15 @@ var restoreComponentFromEnvelope = (envelope, label) => {
     }
     planned.push({ target, content: fe2.content });
   }
-  import_node_fs8.default.mkdirSync(settings.componentsDir, { recursive: true });
+  import_node_fs9.default.mkdirSync(settings.componentsDir, { recursive: true });
   const componentDir = import_node_path10.default.join(settings.componentsDir, componentName);
-  if (import_node_fs8.default.existsSync(componentDir)) {
-    import_node_fs8.default.rmSync(componentDir, { recursive: true, force: true });
+  if (import_node_fs9.default.existsSync(componentDir)) {
+    import_node_fs9.default.rmSync(componentDir, { recursive: true, force: true });
   }
   const written = [];
   for (const item of planned) {
-    import_node_fs8.default.mkdirSync(import_node_path10.default.dirname(item.target), { recursive: true });
-    import_node_fs8.default.writeFileSync(item.target, item.content, "utf8");
+    import_node_fs9.default.mkdirSync(import_node_path10.default.dirname(item.target), { recursive: true });
+    import_node_fs9.default.writeFileSync(item.target, item.content, "utf8");
     written.push(item.target);
   }
   return { componentName, written };
@@ -198178,7 +198212,7 @@ var cardRemotePullCommand = async (cardRef) => {
   const sourceLabel = isPublic ? `r/${effectiveUserId}/${componentName}` : ref.project ? `${effectiveProject}/${componentName}` : componentName;
   const suffix = revision !== undefined ? `@${revision}` : "";
   const service = new PieStorageService(settings);
-  import_node_fs9.default.mkdirSync(settings.componentsDir, { recursive: true });
+  import_node_fs10.default.mkdirSync(settings.componentsDir, { recursive: true });
   if (isPublic) {
     await pullPublicViaTree(service, settings.componentsDir, {
       componentName,
@@ -198205,8 +198239,8 @@ var cardRemotePullCommand = async (cardRef) => {
 var pullPublicViaTree = async (service, componentsDir, args) => {
   const componentDir = import_node_path11.default.join(componentsDir, args.componentName);
   const tempDir = `${componentDir}.pieui-tmp-${process.pid}-${Date.now()}`;
-  import_node_fs9.default.rmSync(tempDir, { recursive: true, force: true });
-  import_node_fs9.default.mkdirSync(tempDir, { recursive: true });
+  import_node_fs10.default.rmSync(tempDir, { recursive: true, force: true });
+  import_node_fs10.default.mkdirSync(tempDir, { recursive: true });
   let downloaded;
   try {
     downloaded = await service.downloadComponentDirectory({
@@ -198216,24 +198250,24 @@ var pullPublicViaTree = async (service, componentsDir, args) => {
       isPublic: true
     });
   } catch (error) {
-    import_node_fs9.default.rmSync(tempDir, { recursive: true, force: true });
+    import_node_fs10.default.rmSync(tempDir, { recursive: true, force: true });
     throw error;
   }
   if (downloaded.length === 0) {
-    import_node_fs9.default.rmSync(tempDir, { recursive: true, force: true });
+    import_node_fs10.default.rmSync(tempDir, { recursive: true, force: true });
     throw new Error(`No typescript files found for remote component r/${args.userId}/${args.componentName} ` + `(user_id=${args.userId} (public))`);
   }
-  if (import_node_fs9.default.existsSync(componentDir)) {
-    import_node_fs9.default.rmSync(componentDir, { recursive: true, force: true });
+  if (import_node_fs10.default.existsSync(componentDir)) {
+    import_node_fs10.default.rmSync(componentDir, { recursive: true, force: true });
   }
-  import_node_fs9.default.renameSync(tempDir, componentDir);
+  import_node_fs10.default.renameSync(tempDir, componentDir);
 };
 var walkFiles = (dir) => {
   const out = [];
-  if (!import_node_fs9.default.existsSync(dir))
+  if (!import_node_fs10.default.existsSync(dir))
     return out;
   const walk = (d) => {
-    for (const entry of import_node_fs9.default.readdirSync(d, { withFileTypes: true })) {
+    for (const entry of import_node_fs10.default.readdirSync(d, { withFileTypes: true })) {
       const abs = import_node_path11.default.join(d, entry.name);
       if (entry.isDirectory())
         walk(abs);
@@ -198388,7 +198422,7 @@ var cardRemotePrivateCommand = async (componentName) => {
 };
 
 // src/code/commands/cardPull.ts
-var import_node_fs10 = __toESM(require("node:fs"));
+var import_node_fs11 = __toESM(require("node:fs"));
 var import_node_path12 = __toESM(require("node:path"));
 var isHttpUrl = (ref) => /^https?:\/\//i.test(ref);
 var isLocalJsonPath = (ref) => {
@@ -198397,7 +198431,7 @@ var isLocalJsonPath = (ref) => {
   }
   if (!ref.endsWith(".json"))
     return false;
-  return import_node_fs10.default.existsSync(import_node_path12.default.resolve(process.cwd(), ref));
+  return import_node_fs11.default.existsSync(import_node_path12.default.resolve(process.cwd(), ref));
 };
 var fetchJsonText = async (url) => {
   const res = await fetch(url);
@@ -198421,13 +198455,13 @@ var cardPullCommand = async (cardRef) => {
   }
   if (isLocalJsonPath(cardRef)) {
     const abs = import_node_path12.default.resolve(process.cwd(), cardRef);
-    if (!import_node_fs10.default.existsSync(abs)) {
+    if (!import_node_fs11.default.existsSync(abs)) {
       throw new Error(`Pull source not found: ${abs}`);
     }
-    if (!import_node_fs10.default.statSync(abs).isFile()) {
+    if (!import_node_fs11.default.statSync(abs).isFile()) {
       throw new Error(`Pull source is not a file: ${abs}`);
     }
-    const { componentName, written } = restoreComponentFromEnvelopeText(import_node_fs10.default.readFileSync(abs, "utf8"), abs);
+    const { componentName, written } = restoreComponentFromEnvelopeText(import_node_fs11.default.readFileSync(abs, "utf8"), abs);
     printRestoreOutput(componentName, written, abs);
     return;
   }
@@ -198435,7 +198469,7 @@ var cardPullCommand = async (cardRef) => {
 };
 
 // src/code/commands/cardView.ts
-var import_node_fs11 = __toESM(require("node:fs"));
+var import_node_fs12 = __toESM(require("node:fs"));
 var import_node_path13 = __toESM(require("node:path"));
 var AJAX_FIELD_NAMES = new Set(["pathname", "deps_names", "kwargs"]);
 var IO_FIELD_RE = /\buse_[A-Za-z0-9_]+_support\b/g;
@@ -198484,14 +198518,14 @@ var formatTable = (headers, rows) => {
 var cardViewCommand = (componentName) => {
   const settings = loadSettings();
   const componentDir = import_node_path13.default.join(settings.componentsDir, componentName);
-  if (!import_node_fs11.default.existsSync(componentDir)) {
+  if (!import_node_fs12.default.existsSync(componentDir)) {
     throw new Error(`Component directory not found: ${componentDir}`);
   }
   const typesPath = import_node_path13.default.join(componentDir, "types.ts");
   const indexPath = import_node_path13.default.join(componentDir, "index.tsx");
   const indexPathTs = import_node_path13.default.join(componentDir, "index.ts");
-  const typesSource = import_node_fs11.default.existsSync(typesPath) ? import_node_fs11.default.readFileSync(typesPath, "utf8") : "";
-  const indexSource = import_node_fs11.default.existsSync(indexPath) ? import_node_fs11.default.readFileSync(indexPath, "utf8") : import_node_fs11.default.existsSync(indexPathTs) ? import_node_fs11.default.readFileSync(indexPathTs, "utf8") : "";
+  const typesSource = import_node_fs12.default.existsSync(typesPath) ? import_node_fs12.default.readFileSync(typesPath, "utf8") : "";
+  const indexSource = import_node_fs12.default.existsSync(indexPath) ? import_node_fs12.default.readFileSync(indexPath, "utf8") : import_node_fs12.default.existsSync(indexPathTs) ? import_node_fs12.default.readFileSync(indexPathTs, "utf8") : "";
   const dataInterface = extractInterfaceBody(typesSource, `${componentName}Data`) ?? "";
   const props = parseProps(dataInterface);
   const hasAjax = props.some((p) => AJAX_FIELD_NAMES.has(p.name));
@@ -198539,7 +198573,7 @@ var cardViewCommand = (componentName) => {
 };
 
 // src/code/commands/cardCheckSync.ts
-var import_node_fs12 = __toESM(require("node:fs"));
+var import_node_fs13 = __toESM(require("node:fs"));
 var import_node_path14 = __toESM(require("node:path"));
 var import_node_child_process2 = require("node:child_process");
 var readline2 = __toESM(require("node:readline/promises"));
@@ -198547,10 +198581,10 @@ var PIE_CONFIG_DIR2 = ".pie";
 var PIE_CONFIG_FILE2 = "config.json";
 var readConfig = (cwd) => {
   const configPath = import_node_path14.default.join(cwd, PIE_CONFIG_DIR2, PIE_CONFIG_FILE2);
-  if (!import_node_fs12.default.existsSync(configPath))
+  if (!import_node_fs13.default.existsSync(configPath))
     return {};
   try {
-    const parsed = JSON.parse(import_node_fs12.default.readFileSync(configPath, "utf8"));
+    const parsed = JSON.parse(import_node_fs13.default.readFileSync(configPath, "utf8"));
     return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {};
   } catch {
     return {};
@@ -198558,15 +198592,15 @@ var readConfig = (cwd) => {
 };
 var writeConfig = (cwd, config) => {
   const dir = import_node_path14.default.join(cwd, PIE_CONFIG_DIR2);
-  import_node_fs12.default.mkdirSync(dir, { recursive: true });
+  import_node_fs13.default.mkdirSync(dir, { recursive: true });
   const configPath = import_node_path14.default.join(dir, PIE_CONFIG_FILE2);
-  import_node_fs12.default.writeFileSync(configPath, JSON.stringify(config, null, 2) + `
+  import_node_fs13.default.writeFileSync(configPath, JSON.stringify(config, null, 2) + `
 `, "utf8");
 };
 var walkUpForPyproject = (start) => {
   let dir = import_node_path14.default.resolve(start);
   while (dir !== import_node_path14.default.dirname(dir)) {
-    if (import_node_fs12.default.existsSync(import_node_path14.default.join(dir, "pyproject.toml")))
+    if (import_node_fs13.default.existsSync(import_node_path14.default.join(dir, "pyproject.toml")))
       return dir;
     dir = import_node_path14.default.dirname(dir);
   }
@@ -198576,7 +198610,7 @@ var ensureBackendDir = async (cwd) => {
   const config = readConfig(cwd);
   if (config.backendProjectDir) {
     const dir = import_node_path14.default.resolve(cwd, config.backendProjectDir);
-    if (import_node_fs12.default.existsSync(dir) && import_node_fs12.default.statSync(dir).isDirectory())
+    if (import_node_fs13.default.existsSync(dir) && import_node_fs13.default.statSync(dir).isDirectory())
       return dir;
     console.error(`[pieui] Configured backendProjectDir not found: ${dir}`);
   }
@@ -198603,7 +198637,7 @@ var ensureBackendDir = async (cwd) => {
       return null;
     const expanded = raw.startsWith("~") ? import_node_path14.default.join(process.env.HOME || "", raw.slice(1).replace(/^[\\/]/, "")) : raw;
     const absolute = import_node_path14.default.resolve(expanded);
-    if (!import_node_fs12.default.existsSync(absolute) || !import_node_fs12.default.statSync(absolute).isDirectory()) {
+    if (!import_node_fs13.default.existsSync(absolute) || !import_node_fs13.default.statSync(absolute).isDirectory()) {
       console.error(`[pieui] Not a directory: ${absolute}`);
       return null;
     }
@@ -198621,7 +198655,7 @@ var findVenvPython = (project) => {
     return override;
   for (const sub of [".venv", "venv"]) {
     const candidate = import_node_path14.default.join(project, sub, "bin", "python");
-    if (import_node_fs12.default.existsSync(candidate))
+    if (import_node_fs13.default.existsSync(candidate))
       return candidate;
   }
   return "python3";
@@ -198654,11 +198688,11 @@ var cardCheckSyncCommand = async (componentName) => {
 };
 
 // src/code/commands/cardAddStory.ts
-var import_node_fs14 = __toESM(require("node:fs"));
+var import_node_fs15 = __toESM(require("node:fs"));
 var import_node_path15 = __toESM(require("node:path"));
 
 // src/code/patchPieCardForwarding.ts
-var import_node_fs13 = __toESM(require("node:fs"));
+var import_node_fs14 = __toESM(require("node:fs"));
 var IO_FIELDS = [
   "useSocketioSupport",
   "useCentrifugeSupport",
@@ -198667,9 +198701,9 @@ var IO_FIELDS = [
 ];
 var FIELD_DECL_RE = (name) => new RegExp(`(^|[\\s\\{,;])${name}\\s*\\??\\s*:`);
 var detectCardIsIO = (typesPath) => {
-  if (!import_node_fs13.default.existsSync(typesPath))
+  if (!import_node_fs14.default.existsSync(typesPath))
     return false;
-  const source = import_node_fs13.default.readFileSync(typesPath, "utf8");
+  const source = import_node_fs14.default.readFileSync(typesPath, "utf8");
   return IO_FIELDS.some((field) => FIELD_DECL_RE(field).test(source));
 };
 var forwardingPropsFor = (isIO) => {
@@ -198710,10 +198744,10 @@ var indentOfFirstAttr = (source, sourceFile, attrs) => {
   return { indent: "            ", multiline: false };
 };
 var patchPieCardForwarding = (uiPath, options = { io: false }) => {
-  if (!import_node_fs13.default.existsSync(uiPath)) {
+  if (!import_node_fs14.default.existsSync(uiPath)) {
     return { patched: false, addedPerSite: [] };
   }
-  const source = import_node_fs13.default.readFileSync(uiPath, "utf8");
+  const source = import_node_fs14.default.readFileSync(uiPath, "utf8");
   const sourceFile = ts2.createSourceFile(uiPath, source, ts2.ScriptTarget.ES2020, true, ts2.ScriptKind.TSX);
   const required = forwardingPropsFor(options.io);
   const insertions = [];
@@ -198757,7 +198791,7 @@ ${indent}${p.name}={${p.expr}}` : ` ${p.name}={${p.expr}}`).join("");
   for (const ins of insertions) {
     result = result.slice(0, ins.pos) + ins.text + result.slice(ins.pos);
   }
-  import_node_fs13.default.writeFileSync(uiPath, result, "utf8");
+  import_node_fs14.default.writeFileSync(uiPath, result, "utf8");
   return { patched: true, addedPerSite };
 };
 
@@ -198872,7 +198906,7 @@ var cardAddStoryCommand = (componentName, options = {}) => {
   }
   const settings = loadSettings();
   const componentDir = import_node_path15.default.join(settings.componentsDir, componentName);
-  if (!import_node_fs14.default.existsSync(componentDir)) {
+  if (!import_node_fs15.default.existsSync(componentDir)) {
     throw new Error(`Component directory not found: ${componentDir}`);
   }
   const tsFiles = collectComponentFiles2(componentDir).filter((f) => COMPONENT_EXTS4.some((e) => f.endsWith(e)));
@@ -198900,12 +198934,12 @@ var cardAddStoryCommand = (componentName, options = {}) => {
   const uiPath = import_node_path15.default.join(componentDir, "ui", `${componentName}.tsx`);
   const io = detectCardIsIO(typesPath);
   const storyPath = import_node_path15.default.join(componentDir, `${componentName}.stories.tsx`);
-  const storyExists = import_node_fs14.default.existsSync(storyPath);
+  const storyExists = import_node_fs15.default.existsSync(storyPath);
   if (storyExists && !options.force) {
     throw new Error(`Story file already exists: ${storyPath}
 ` + `Pass --force to overwrite.`);
   }
-  import_node_fs14.default.writeFileSync(storyPath, renderStoryFile(componentName, events, payloads, { io }), "utf8");
+  import_node_fs15.default.writeFileSync(storyPath, renderStoryFile(componentName, events, payloads, { io }), "utf8");
   console.log(`[pieui] Story ${storyExists ? "overwritten" : "created"}: ${storyPath}`);
   if (events.length > 0) {
     console.log(`[pieui] Methods wired: ${events.join(", ")}`);
@@ -198940,7 +198974,7 @@ var cardAddStoryCommand = (componentName, options = {}) => {
 };
 
 // src/code/commands/cardGeneratePreview.ts
-var import_node_fs15 = __toESM(require("node:fs"));
+var import_node_fs16 = __toESM(require("node:fs"));
 var import_node_http = __toESM(require("node:http"));
 var import_node_os = __toESM(require("node:os"));
 var import_node_path16 = __toESM(require("node:path"));
@@ -198984,16 +199018,16 @@ var cardGeneratePreviewCommand = async (componentName, options = {}) => {
   }
   const settings = loadSettings();
   const componentDir = import_node_path16.default.join(settings.componentsDir, componentName);
-  if (!import_node_fs15.default.existsSync(componentDir)) {
+  if (!import_node_fs16.default.existsSync(componentDir)) {
     throw new Error(`Component directory not found: ${componentDir}`);
   }
   const storyPath = import_node_path16.default.join(componentDir, `${componentName}.stories.tsx`);
-  if (!import_node_fs15.default.existsSync(storyPath)) {
+  if (!import_node_fs16.default.existsSync(storyPath)) {
     throw new Error(`Story file not found: ${storyPath}
 ` + `Run \`pieui card add-story ${componentName}\` first.`);
   }
   const outPath = import_node_path16.default.resolve(process.cwd(), options.out || import_node_path16.default.join(componentDir, "preview.png"));
-  import_node_fs15.default.mkdirSync(import_node_path16.default.dirname(outPath), { recursive: true });
+  import_node_fs16.default.mkdirSync(import_node_path16.default.dirname(outPath), { recursive: true });
   const bunBin = process.env.PIEUI_CREATE_BUN_BIN || "bun";
   let sbProc = null;
   const alreadyRunning = await isStorybookReachable(STORYBOOK_PORT);
@@ -199015,7 +199049,7 @@ var cardGeneratePreviewCommand = async (componentName, options = {}) => {
   } else {
     console.log(`[pieui] Using running Storybook on :${STORYBOOK_PORT}`);
   }
-  const tmpDir = import_node_fs15.default.mkdtempSync(import_node_path16.default.join(import_node_os.default.tmpdir(), "pieui-storycap-"));
+  const tmpDir = import_node_fs16.default.mkdtempSync(import_node_path16.default.join(import_node_os.default.tmpdir(), "pieui-storycap-"));
   try {
     const include = `${STORY_TITLE_NAMESPACE}/${componentName}/*`;
     console.log(`[pieui] Running storycap for "${include}"...`);
@@ -199041,19 +199075,19 @@ var cardGeneratePreviewCommand = async (componentName, options = {}) => {
       throw new Error(`storycap exited with code ${result.status ?? "unknown"}`);
     }
     const producedDir = import_node_path16.default.join(tmpDir, STORY_TITLE_NAMESPACE, componentName);
-    if (!import_node_fs15.default.existsSync(producedDir)) {
+    if (!import_node_fs16.default.existsSync(producedDir)) {
       throw new Error(`storycap finished but no PNGs were produced under ${producedDir}
-` + `Tmp listing: ${import_node_fs15.default.readdirSync(tmpDir).join(", ") || "(empty)"}`);
+` + `Tmp listing: ${import_node_fs16.default.readdirSync(tmpDir).join(", ") || "(empty)"}`);
     }
-    const pngs = import_node_fs15.default.readdirSync(producedDir).filter((f) => f.endsWith(".png")).sort();
+    const pngs = import_node_fs16.default.readdirSync(producedDir).filter((f) => f.endsWith(".png")).sort();
     if (pngs.length === 0) {
       throw new Error(`No PNGs in ${producedDir}`);
     }
     const picked = import_node_path16.default.join(producedDir, pngs[0]);
-    import_node_fs15.default.copyFileSync(picked, outPath);
+    import_node_fs16.default.copyFileSync(picked, outPath);
     console.log(`[pieui] Preview written: ${outPath}` + (pngs.length > 1 ? ` (picked ${pngs[0]}; other states available: ${pngs.slice(1).join(", ")})` : ""));
   } finally {
-    import_node_fs15.default.rmSync(tmpDir, { recursive: true, force: true });
+    import_node_fs16.default.rmSync(tmpDir, { recursive: true, force: true });
     if (sbProc) {
       killProcessTree(sbProc);
       console.log("[pieui] Storybook stopped");
@@ -199062,7 +199096,7 @@ var cardGeneratePreviewCommand = async (componentName, options = {}) => {
 };
 
 // src/code/commands/cardAddFromMeta.ts
-var import_node_fs16 = __toESM(require("node:fs"));
+var import_node_fs17 = __toESM(require("node:fs"));
 var import_node_path17 = __toESM(require("node:path"));
 var import_node_child_process4 = require("node:child_process");
 
@@ -199145,10 +199179,10 @@ var jsonSchemaToTsType = (schema) => renderType(asSchema(schema), 0);
 var PIE_CONFIG_PATH = ".pie/config.json";
 var readBackendConfig = () => {
   const configPath = import_node_path17.default.join(process.cwd(), PIE_CONFIG_PATH);
-  if (!import_node_fs16.default.existsSync(configPath))
+  if (!import_node_fs17.default.existsSync(configPath))
     return null;
   try {
-    const parsed = JSON.parse(import_node_fs16.default.readFileSync(configPath, "utf8"));
+    const parsed = JSON.parse(import_node_fs17.default.readFileSync(configPath, "utf8"));
     if (typeof parsed !== "object" || parsed === null)
       return null;
     return parsed;
@@ -199165,8 +199199,8 @@ var cardNameToClassFilename = (name) => {
   return snake.endsWith("_card") ? `${snake}.py` : `${snake}_card.py`;
 };
 var resolveSource = (fromRaw, cardName, cfg) => {
-  if (fromRaw && import_node_fs16.default.existsSync(fromRaw)) {
-    const stat = import_node_fs16.default.statSync(fromRaw);
+  if (fromRaw && import_node_fs17.default.existsSync(fromRaw)) {
+    const stat = import_node_fs17.default.statSync(fromRaw);
     const abs = import_node_path17.default.resolve(fromRaw);
     if (stat.isFile() && abs.endsWith(".json")) {
       return { kind: "json-file", path: abs };
@@ -199216,7 +199250,7 @@ var unwrapTypescriptEnvelope2 = (parsed) => {
 };
 var fetchMetadata = (source) => {
   if (source.kind === "json-file") {
-    const raw = import_node_fs16.default.readFileSync(source.path, "utf8");
+    const raw = import_node_fs17.default.readFileSync(source.path, "utf8");
     return unwrapTypescriptEnvelope2(JSON.parse(raw));
   }
   console.log(`[pieui] Invoking: pie card dump-metadata ${source.cardName} (cwd: ${source.backendRoot})`);
@@ -199352,10 +199386,10 @@ var renderUI = (componentName, meta, inputInterfaceName) => {
 };
 var updateRegistryFile2 = (componentsDir, componentName) => {
   const registryPath = resolveRegistryPath(componentsDir);
-  if (!import_node_fs16.default.existsSync(registryPath)) {
+  if (!import_node_fs17.default.existsSync(registryPath)) {
     throw new Error('registry.ts not found. Run "pieui init" first.');
   }
-  let registryContent = import_node_fs16.default.readFileSync(registryPath, "utf8");
+  let registryContent = import_node_fs17.default.readFileSync(registryPath, "utf8");
   const importRegex = new RegExp(`["']@/piecomponents/${componentName}["']`);
   if (importRegex.test(registryContent)) {
     throw new Error(`Component ${componentName} is already registered in registry.ts`);
@@ -199364,17 +199398,17 @@ var updateRegistryFile2 = (componentsDir, componentName) => {
   registryContent = registryContent.trimEnd() + `
 ` + importLine + `
 `;
-  import_node_fs16.default.writeFileSync(registryPath, registryContent, "utf8");
+  import_node_fs17.default.writeFileSync(registryPath, registryContent, "utf8");
 };
 var hasBackendSourceFor = (componentName) => {
   const cfg = readBackendConfig();
   if (!cfg?.backendComponentsDir)
     return false;
   const componentsDir = import_node_path17.default.resolve(cfg.backendComponentsDir);
-  if (!import_node_fs16.default.existsSync(componentsDir))
+  if (!import_node_fs17.default.existsSync(componentsDir))
     return false;
   const candidate = import_node_path17.default.join(componentsDir, cardNameToClassFilename(componentName));
-  return import_node_fs16.default.existsSync(candidate);
+  return import_node_fs17.default.existsSync(candidate);
 };
 var cardAddFromMetaCommand = (componentName, componentType, fromRaw) => {
   if (!componentName) {
@@ -199387,7 +199421,7 @@ var cardAddFromMetaCommand = (componentName, componentType, fromRaw) => {
   const source = resolveSource(fromRaw, componentName, cfg);
   if (source.kind === "name") {
     const candidate = import_node_path17.default.join(source.backendRoot, import_node_path17.default.basename(import_node_path17.default.resolve(cfg.backendComponentsDir)), cardNameToClassFilename(source.cardName));
-    if (!import_node_fs16.default.existsSync(candidate)) {
+    if (!import_node_fs17.default.existsSync(candidate)) {
       console.warn(`[pieui] Note: expected backend file ${candidate} not found; relying on pie's resolution`);
     }
   }
@@ -199396,22 +199430,22 @@ var cardAddFromMetaCommand = (componentName, componentType, fromRaw) => {
   const dataInterfaceName = extractTypeName(meta.propsCode) || `${componentName}Data`;
   const inputInterfaceName = meta.inputPropsCode ? extractTypeName(meta.inputPropsCode) || `${componentName}StoredInput` : null;
   const pieComponentsDir = import_node_path17.default.join(process.cwd(), "piecomponents");
-  if (!import_node_fs16.default.existsSync(pieComponentsDir)) {
+  if (!import_node_fs17.default.existsSync(pieComponentsDir)) {
     throw new Error('piecomponents directory not found. Run "pieui init" first.');
   }
   const componentDir = import_node_path17.default.join(pieComponentsDir, componentName);
-  if (import_node_fs16.default.existsSync(componentDir)) {
+  if (import_node_fs17.default.existsSync(componentDir)) {
     throw new Error(`Component ${componentName} already exists`);
   }
   try {
-    import_node_fs16.default.mkdirSync(import_node_path17.default.join(componentDir, "ui"), { recursive: true });
-    import_node_fs16.default.mkdirSync(import_node_path17.default.join(componentDir, "types"), { recursive: true });
-    import_node_fs16.default.writeFileSync(import_node_path17.default.join(componentDir, "index.ts"), componentIndexTemplate(componentName), "utf8");
-    import_node_fs16.default.writeFileSync(import_node_path17.default.join(componentDir, "types", "index.ts"), renderTypes(componentName, componentType, meta, dataInterfaceName, inputInterfaceName), "utf8");
-    import_node_fs16.default.writeFileSync(import_node_path17.default.join(componentDir, "ui", `${componentName}.tsx`), renderUI(componentName, meta, inputInterfaceName), "utf8");
+    import_node_fs17.default.mkdirSync(import_node_path17.default.join(componentDir, "ui"), { recursive: true });
+    import_node_fs17.default.mkdirSync(import_node_path17.default.join(componentDir, "types"), { recursive: true });
+    import_node_fs17.default.writeFileSync(import_node_path17.default.join(componentDir, "index.ts"), componentIndexTemplate(componentName), "utf8");
+    import_node_fs17.default.writeFileSync(import_node_path17.default.join(componentDir, "types", "index.ts"), renderTypes(componentName, componentType, meta, dataInterfaceName, inputInterfaceName), "utf8");
+    import_node_fs17.default.writeFileSync(import_node_path17.default.join(componentDir, "ui", `${componentName}.tsx`), renderUI(componentName, meta, inputInterfaceName), "utf8");
     updateRegistryFile2(pieComponentsDir, componentName);
   } catch (error) {
-    import_node_fs16.default.rmSync(componentDir, { recursive: true, force: true });
+    import_node_fs17.default.rmSync(componentDir, { recursive: true, force: true });
     throw error;
   }
   console.log(`[pieui] Component ${componentName} ported from backend successfully`);
@@ -199478,7 +199512,7 @@ var pageAddCommand = (pagePath) => {
 };
 
 // src/code/commands/pageView.ts
-var import_node_fs17 = __toESM(require("node:fs"));
+var import_node_fs18 = __toESM(require("node:fs"));
 var import_node_path18 = __toESM(require("node:path"));
 var normalizePagePath2 = (pagePath) => {
   const trimmed = pagePath.trim();
@@ -199500,10 +199534,10 @@ var normalizePagePath2 = (pagePath) => {
 var pageViewCommand = (pagePath) => {
   const normalized = normalizePagePath2(pagePath);
   const target = import_node_path18.default.join(process.cwd(), "app", normalized, "page.tsx");
-  if (!import_node_fs17.default.existsSync(target)) {
+  if (!import_node_fs18.default.existsSync(target)) {
     throw new Error(`Page file not found: ${target}`);
   }
-  const source = import_node_fs17.default.readFileSync(target, "utf8");
+  const source = import_node_fs18.default.readFileSync(target, "utf8");
   console.log(`[pieui] Path: ${target}`);
   console.log("");
   process.stdout.write(source);
@@ -199513,23 +199547,23 @@ var pageViewCommand = (pagePath) => {
 };
 
 // src/code/commands/pageAjax.ts
-var import_node_fs18 = __toESM(require("node:fs"));
+var import_node_fs19 = __toESM(require("node:fs"));
 var import_node_path19 = __toESM(require("node:path"));
 var import_node_child_process5 = require("node:child_process");
 var PIE_CONFIG_PATH2 = ".pie/config.json";
 var readBackendRoot = () => {
   const configPath = import_node_path19.default.join(process.cwd(), PIE_CONFIG_PATH2);
-  if (!import_node_fs18.default.existsSync(configPath))
+  if (!import_node_fs19.default.existsSync(configPath))
     return;
   try {
-    const parsed = JSON.parse(import_node_fs18.default.readFileSync(configPath, "utf8"));
+    const parsed = JSON.parse(import_node_fs19.default.readFileSync(configPath, "utf8"));
     if (typeof parsed !== "object" || parsed === null)
       return;
     const config = parsed;
     if (!config.backendPagesDir)
       return;
     const pages = import_node_path19.default.resolve(config.backendPagesDir);
-    if (!import_node_fs18.default.existsSync(pages) || !import_node_fs18.default.statSync(pages).isDirectory()) {
+    if (!import_node_fs19.default.existsSync(pages) || !import_node_fs19.default.statSync(pages).isDirectory()) {
       return;
     }
     return import_node_path19.default.dirname(pages);
@@ -199559,17 +199593,17 @@ var pageAjaxCommand = (pageName, action, handlerName) => {
 };
 
 // src/code/commands/registry.ts
-var import_node_fs19 = __toESM(require("node:fs"));
+var import_node_fs20 = __toESM(require("node:fs"));
 var import_node_path20 = __toESM(require("node:path"));
 var import_node_child_process6 = require("node:child_process");
 var REGISTRY_DIR = ".pie/registry";
 var OUT_DIRNAME = "out";
 var writeIfChanged = (filePath, contents) => {
-  if (import_node_fs19.default.existsSync(filePath) && import_node_fs19.default.readFileSync(filePath, "utf8") === contents) {
+  if (import_node_fs20.default.existsSync(filePath) && import_node_fs20.default.readFileSync(filePath, "utf8") === contents) {
     return;
   }
-  import_node_fs19.default.mkdirSync(import_node_path20.default.dirname(filePath), { recursive: true });
-  import_node_fs19.default.writeFileSync(filePath, contents, "utf8");
+  import_node_fs20.default.mkdirSync(import_node_path20.default.dirname(filePath), { recursive: true });
+  import_node_fs20.default.writeFileSync(filePath, contents, "utf8");
 };
 var scaffoldHarness = (frontendRoot, registryName) => {
   const dir = import_node_path20.default.join(frontendRoot, REGISTRY_DIR);
@@ -199701,7 +199735,7 @@ export default function PreviewClient() {
 };
 var resolveNextBin = (frontendRoot) => {
   const bin = import_node_path20.default.join(frontendRoot, "node_modules", ".bin", "next");
-  if (!import_node_fs19.default.existsSync(bin)) {
+  if (!import_node_fs20.default.existsSync(bin)) {
     throw new Error(`Next.js binary not found at ${bin}. Install dependencies in the ` + `frontend project first (the registry harness reuses them).`);
   }
   return bin;
@@ -200112,11 +200146,11 @@ var createPieAppCommand = (appName) => {
 // src/code/commands/login.ts
 var import_node_child_process7 = require("node:child_process");
 var import_node_crypto = require("node:crypto");
-var import_node_fs21 = __toESM(require("node:fs"));
+var import_node_fs22 = __toESM(require("node:fs"));
 var import_node_path22 = __toESM(require("node:path"));
 
 // src/code/services/projectLinks.ts
-var import_node_fs20 = __toESM(require("node:fs"));
+var import_node_fs21 = __toESM(require("node:fs"));
 var import_node_path21 = __toESM(require("node:path"));
 var readline3 = __toESM(require("node:readline/promises"));
 var PIE_CONFIG_DIR3 = ".pie";
@@ -200124,10 +200158,10 @@ var PIE_CONFIG_FILE3 = "config.json";
 var configPathFor = (cwd) => import_node_path21.default.join(cwd, PIE_CONFIG_DIR3, PIE_CONFIG_FILE3);
 var readConfig2 = (cwd) => {
   const p = configPathFor(cwd);
-  if (!import_node_fs20.default.existsSync(p))
+  if (!import_node_fs21.default.existsSync(p))
     return {};
   try {
-    const parsed = JSON.parse(import_node_fs20.default.readFileSync(p, "utf8"));
+    const parsed = JSON.parse(import_node_fs21.default.readFileSync(p, "utf8"));
     return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {};
   } catch {
     return {};
@@ -200135,14 +200169,14 @@ var readConfig2 = (cwd) => {
 };
 var writeConfig2 = (cwd, config) => {
   const dir = import_node_path21.default.join(cwd, PIE_CONFIG_DIR3);
-  import_node_fs20.default.mkdirSync(dir, { recursive: true });
-  import_node_fs20.default.writeFileSync(configPathFor(cwd), JSON.stringify(config, null, 2) + `
+  import_node_fs21.default.mkdirSync(dir, { recursive: true });
+  import_node_fs21.default.writeFileSync(configPathFor(cwd), JSON.stringify(config, null, 2) + `
 `, "utf8");
 };
 var walkUpForPyproject2 = (start) => {
   let dir = import_node_path21.default.resolve(start);
   while (dir !== import_node_path21.default.dirname(dir)) {
-    if (import_node_fs20.default.existsSync(import_node_path21.default.join(dir, "pyproject.toml")))
+    if (import_node_fs21.default.existsSync(import_node_path21.default.join(dir, "pyproject.toml")))
       return dir;
     dir = import_node_path21.default.dirname(dir);
   }
@@ -200152,7 +200186,7 @@ var ensureBackendDir2 = async (cwd) => {
   const config = readConfig2(cwd);
   if (config.backendProjectDir) {
     const dir = import_node_path21.default.resolve(cwd, config.backendProjectDir);
-    if (import_node_fs20.default.existsSync(dir) && import_node_fs20.default.statSync(dir).isDirectory())
+    if (import_node_fs21.default.existsSync(dir) && import_node_fs21.default.statSync(dir).isDirectory())
       return dir;
     console.error(`[pieui] Configured backendProjectDir not found: ${dir}`);
   }
@@ -200179,7 +200213,7 @@ var ensureBackendDir2 = async (cwd) => {
       return null;
     const expanded = raw.startsWith("~") ? import_node_path21.default.join(process.env.HOME || "", raw.slice(1).replace(/^[\\/]/, "")) : raw;
     const absolute = import_node_path21.default.resolve(expanded);
-    if (!import_node_fs20.default.existsSync(absolute) || !import_node_fs20.default.statSync(absolute).isDirectory()) {
+    if (!import_node_fs21.default.existsSync(absolute) || !import_node_fs21.default.statSync(absolute).isDirectory()) {
       console.error(`[pieui] Not a directory: ${absolute}`);
       return null;
     }
@@ -200249,7 +200283,7 @@ var appendPieCredentialsToEnv = (cwd, config) => {
     return;
   }
   const envPath = import_node_path22.default.join(cwd, ".env");
-  let content = import_node_fs21.default.existsSync(envPath) ? import_node_fs21.default.readFileSync(envPath, "utf8") : "";
+  let content = import_node_fs22.default.existsSync(envPath) ? import_node_fs22.default.readFileSync(envPath, "utf8") : "";
   if (content.length > 0 && !content.endsWith(`
 `)) {
     content += `
@@ -200259,7 +200293,7 @@ var appendPieCredentialsToEnv = (cwd, config) => {
   content += `${additions.join(`
 `)}
 `;
-  import_node_fs21.default.writeFileSync(envPath, content, "utf8");
+  import_node_fs22.default.writeFileSync(envPath, content, "utf8");
   console.log(`[pie] Appended credentials to ${envPath}`);
 };
 async function loginCommand(options = {}) {
@@ -200315,7 +200349,7 @@ async function loginCommand(options = {}) {
         throw new Error("Login succeeded but response had no 'config' field");
       }
       const credBlob = typeof record.config === "object" && record.config !== null && !Array.isArray(record.config) ? record.config : {};
-      import_node_fs21.default.mkdirSync(pieDir, { recursive: true });
+      import_node_fs22.default.mkdirSync(pieDir, { recursive: true });
       mergeConfig(cwd, credBlob);
       console.log(`[pie] Saved credentials to ${configPath}`);
       appendPieCredentialsToEnv(cwd, record.config);
@@ -200331,7 +200365,7 @@ async function loginCommand(options = {}) {
 
 // src/code/commands/selfUpgrade.ts
 var import_node_child_process8 = require("node:child_process");
-var import_node_fs22 = __toESM(require("node:fs"));
+var import_node_fs23 = __toESM(require("node:fs"));
 var import_node_path23 = __toESM(require("node:path"));
 var __dirname = "/home/runner/work/pieui/pieui/src/code/commands";
 var PACKAGE_NAME = "@swarm.ing/pieui";
@@ -200362,7 +200396,7 @@ var readInstalledVersion = () => {
   ];
   for (const file of candidates) {
     try {
-      const raw = import_node_fs22.default.readFileSync(file, "utf8");
+      const raw = import_node_fs23.default.readFileSync(file, "utf8");
       const parsed = JSON.parse(raw);
       if (parsed.name === PACKAGE_NAME && parsed.version) {
         return parsed.version;