hanoman 0.1.33 → 0.1.34

package/README.md

@@ -127,7 +127,9 @@ Sesi hanoman hidup di dalam **tmux**; layarnya dialirkan ke browser lewat node-p
 - **tmux belum terpasang** — `brew install tmux` (macOS) atau paket distro Anda.
 - **`spawn-helper` node-pty tak executable** — node-pty menerbitkan biner pendampingnya dengan mode
   `0644`, jadi `posix_spawnp` gagal dan tak satu byte pun mengalir ke terminal walau sesinya hidup.
-  Sejak `0.1.3` `hanoman` memperbaikinya sendiri saat start (sekali per instalasi). Bila instalasi
+  Sejak `0.1.3` `hanoman` memperbaikinya sendiri saat start, dan sejak `0.1.34` perbaikan itu
+  dipasang di jembatan node-pty-nya sendiri — jadi ia tetap jalan walau Anda memanggil bundle
+  server langsung (`node .../hanoman/dist/server.js`) alih-alih lewat `hanoman start`. Bila instalasi
   global itu milik root dan hanoman dijalankan sebagai pengguna biasa, chmod-nya ditolak — perbaiki
   manual: `sudo chmod +x "$(npm root -g)"/hanoman/node_modules/node-pty/prebuilds/*/spawn-helper`.
 

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.33",
-  "sha": "5b0ee20",
-  "builtAt": "2026-08-14T10:11:20.930Z"
+  "version": "0.1.34",
+  "sha": "2391410",
+  "builtAt": "2026-08-14T11:14:44.309Z"
 }

package/dist/cli.js

@@ -7571,6 +7571,54 @@ var init_telegram_operator = __esm({
   }
 });
 
+// ../runner/src/spawn-helper.ts
+import { readdirSync as readdirSync2, existsSync as existsSync2, statSync, chmodSync } from "node:fs";
+import { dirname as dirname3, join as join3 } from "node:path";
+function spawnHelperPaths(ptyDir, listDir, exists) {
+  const dirs = [join3(ptyDir, "build", "Release")];
+  for (const name of listDir(join3(ptyDir, "prebuilds"))) dirs.push(join3(ptyDir, "prebuilds", name));
+  return dirs.map((d) => join3(d, "spawn-helper")).filter(exists);
+}
+function ensureSpawnHelpersExecutable(paths2, ops) {
+  const fixed = [];
+  for (const p of paths2) {
+    try {
+      const mode = ops.mode(p) & 4095;
+      if ((mode & 73) === 73) continue;
+      ops.chmod(p, mode | 73);
+      fixed.push(p);
+    } catch {
+    }
+  }
+  return fixed;
+}
+function repairSpawnHelper(resolve4, notify) {
+  let ptyDir;
+  try {
+    ptyDir = dirname3(resolve4("node-pty/package.json"));
+  } catch {
+    return [];
+  }
+  const paths2 = spawnHelperPaths(ptyDir, (d) => {
+    try {
+      return readdirSync2(d);
+    } catch {
+      return [];
+    }
+  }, existsSync2);
+  const fixed = ensureSpawnHelpersExecutable(paths2, {
+    mode: (p) => statSync(p).mode,
+    chmod: (p, m) => chmodSync(p, m)
+  });
+  if (fixed.length) notify?.("hanoman \xB7 memperbaiki izin `spawn-helper` node-pty (sekali per instalasi)\n");
+  return fixed;
+}
+var init_spawn_helper = __esm({
+  "../runner/src/spawn-helper.ts"() {
+    "use strict";
+  }
+});
+
 // ../runner/src/index.ts
 var init_src2 = __esm({
   "../runner/src/index.ts"() {
@@ -7590,28 +7638,29 @@ var init_src2 = __esm({
     init_paths();
     init_skills();
     init_telegram_operator();
+    init_spawn_helper();
   }
 });
 
 // src/layout.ts
-import { join as join3, resolve as resolve3 } from "node:path";
+import { join as join4, resolve as resolve3 } from "node:path";
 function resolveLayout(distDir2, exists) {
   const pkg = resolve3(distDir2, "..");
-  if (exists(join3(pkg, "prisma", "schema.prisma"))) {
+  if (exists(join4(pkg, "prisma", "schema.prisma"))) {
     return {
       root: pkg,
-      schema: join3(pkg, "prisma", "schema.prisma"),
-      server: join3(pkg, "dist", "server.js"),
-      web: exists(join3(pkg, "web")) ? join3(pkg, "web") : null
+      schema: join4(pkg, "prisma", "schema.prisma"),
+      server: join4(pkg, "dist", "server.js"),
+      web: exists(join4(pkg, "web")) ? join4(pkg, "web") : null
     };
   }
   const repo = resolve3(distDir2, "../..");
-  if (exists(join3(repo, "server", "prisma", "schema.prisma"))) {
+  if (exists(join4(repo, "server", "prisma", "schema.prisma"))) {
     return {
       root: repo,
-      schema: join3(repo, "server", "prisma", "schema.prisma"),
-      server: join3(repo, "server", "dist", "server.js"),
-      web: exists(join3(repo, "src", "dist")) ? join3(repo, "src", "dist") : null
+      schema: join4(repo, "server", "prisma", "schema.prisma"),
+      server: join4(repo, "server", "dist", "server.js"),
+      web: exists(join4(repo, "src", "dist")) ? join4(repo, "src", "dist") : null
     };
   }
   throw new Error(`hanoman: prisma/schema.prisma tak ditemukan dari ${distDir2} \u2014 instalasi rusak?`);
@@ -7697,20 +7746,17 @@ __export(start_exports, {
   default: () => start,
   distDir: () => distDir,
   ensurePrismaClient: () => ensurePrismaClient,
-  ensureSpawnHelpersExecutable: () => ensureSpawnHelpersExecutable,
   installLatest: () => installLatest,
   migrateFailureHint: () => migrateFailureHint,
   parseStartArgs: () => parseStartArgs,
   planSupervisorStep: () => planSupervisorStep,
   prismaClientUsable: () => prismaClientUsable,
-  repairSpawnHelper: () => repairSpawnHelper,
-  serverEnv: () => serverEnv,
-  spawnHelperPaths: () => spawnHelperPaths
+  serverEnv: () => serverEnv
 });
 import { spawn, execFileSync as execFileSync2 } from "node:child_process";
 import { createRequire } from "node:module";
-import { existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, statSync, chmodSync } from "node:fs";
-import { dirname as dirname3, join as join4, resolve as resolvePath } from "node:path";
+import { existsSync as existsSync3, mkdirSync, chmodSync as chmodSync2 } from "node:fs";
+import { dirname as dirname4, resolve as resolvePath } from "node:path";
 import { fileURLToPath } from "node:url";
 function parseStartArgs(argv) {
   const out = { port: null, host: null, db: null, migrate: true };
@@ -7751,7 +7797,7 @@ function parseStartArgs(argv) {
   return out;
 }
 function distDir() {
-  return dirname3(fileURLToPath(import.meta.url));
+  return dirname4(fileURLToPath(import.meta.url));
 }
 function runPrisma(args, dbUrl) {
   const prismaCli = prismaCliPath(createRequire(import.meta.url).resolve);
@@ -7802,43 +7848,8 @@ async function ensurePrismaClient(schema, dbUrl, ctx) {
     return false;
   }
 }
-function spawnHelperPaths(ptyDir, listDir, exists) {
-  const dirs = [join4(ptyDir, "build", "Release")];
-  for (const name of listDir(join4(ptyDir, "prebuilds"))) dirs.push(join4(ptyDir, "prebuilds", name));
-  return dirs.map((d) => join4(d, "spawn-helper")).filter(exists);
-}
-function ensureSpawnHelpersExecutable(paths2, ops) {
-  const fixed = [];
-  for (const p of paths2) {
-    try {
-      const mode = ops.mode(p) & 4095;
-      if ((mode & 73) === 73) continue;
-      ops.chmod(p, mode | 73);
-      fixed.push(p);
-    } catch {
-    }
-  }
-  return fixed;
-}
-function repairSpawnHelper(ctx) {
-  let ptyDir;
-  try {
-    ptyDir = dirname3(createRequire(import.meta.url).resolve("node-pty/package.json"));
-  } catch {
-    return;
-  }
-  const paths2 = spawnHelperPaths(ptyDir, (d) => {
-    try {
-      return readdirSync2(d);
-    } catch {
-      return [];
-    }
-  }, existsSync2);
-  const fixed = ensureSpawnHelpersExecutable(paths2, {
-    mode: (p) => statSync(p).mode,
-    chmod: (p, m) => chmodSync(p, m)
-  });
-  if (fixed.length) ctx.stdout("hanoman \xB7 memperbaiki izin `spawn-helper` node-pty (sekali per instalasi)\n");
+function repairSpawnHelperEarly(ctx) {
+  repairSpawnHelper(createRequire(import.meta.url).resolve, ctx.stdout);
 }
 function planSupervisorStep(code, restartsUsed) {
   if (code !== UPDATE_RESTART_EXIT) return { action: "exit", code };
@@ -7886,8 +7897,8 @@ async function start(argv, ctx) {
   let layout;
   let dbUrl;
   try {
-    layout = resolveLayout(distDir(), existsSync2);
-    dbUrl = opts.db ? `file:${resolvePath(opts.db)}` : resolveDbUrl(ctx.env, dirname3(layout.schema));
+    layout = resolveLayout(distDir(), existsSync3);
+    dbUrl = opts.db ? `file:${resolvePath(opts.db)}` : resolveDbUrl(ctx.env, dirname4(layout.schema));
   } catch (e) {
     ctx.stderr(`${e.message}
 `);
@@ -7898,15 +7909,15 @@ async function start(argv, ctx) {
 `);
   const home = resolveHome(ctx.env);
   mkdirSync(home, { recursive: true, mode: 448 });
-  chmodSync(home, 448);
-  mkdirSync(dirname3(dbFilePath(dbUrl)), { recursive: true, mode: 448 });
-  if (!existsSync2(layout.server)) {
+  chmodSync2(home, 448);
+  mkdirSync(dirname4(dbFilePath(dbUrl)), { recursive: true, mode: 448 });
+  if (!existsSync3(layout.server)) {
     ctx.stderr(`hanoman: bundle server tak ada di ${layout.server} \u2014 jalankan \`pnpm build\` dulu
 `);
     return 1;
   }
   if (!await ensurePrismaClient(layout.schema, dbUrl, ctx)) return 1;
-  repairSpawnHelper(ctx);
+  repairSpawnHelperEarly(ctx);
   if (opts.migrate) {
     ctx.stdout(`hanoman \xB7 menerapkan migrasi ke ${dbFilePath(dbUrl)}
 `);
@@ -7920,7 +7931,7 @@ ${hint}
       return 1;
     }
   }
-  if (existsSync2(dbFilePath(dbUrl))) chmodSync(dbFilePath(dbUrl), 384);
+  if (existsSync3(dbFilePath(dbUrl))) chmodSync2(dbFilePath(dbUrl), 384);
   const port = opts.port ?? Number(ctx.env.PORT ?? 8787);
   const host = opts.host ?? ctx.env.HOST ?? "127.0.0.1";
   ctx.stdout(`hanoman \xB7 http://${host === "0.0.0.0" ? "127.0.0.1" : host}:${port}
@@ -7985,8 +7996,8 @@ __export(doctor_exports, {
   doctorReport: () => doctorReport
 });
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { accessSync, constants, existsSync as existsSync3 } from "node:fs";
-import { dirname as dirname4 } from "node:path";
+import { accessSync, constants, existsSync as existsSync4 } from "node:fs";
+import { dirname as dirname5 } from "node:path";
 function doctorReport(p) {
   const major = Number(/^v?(\d+)/.exec(p.node)?.[1] ?? 0);
   const rows = [
@@ -8035,8 +8046,8 @@ async function doctor(_argv, ctx) {
   let layout;
   let db;
   try {
-    layout = resolveLayout(distDir(), existsSync3);
-    db = dbFilePath(resolveDbUrl(ctx.env, dirname4(layout.schema)));
+    layout = resolveLayout(distDir(), existsSync4);
+    db = dbFilePath(resolveDbUrl(ctx.env, dirname5(layout.schema)));
   } catch (e) {
     ctx.stderr(`${e.message}
 `);
@@ -8045,7 +8056,7 @@ async function doctor(_argv, ctx) {
   const home = resolveHome(ctx.env);
   let homeWritable = false;
   try {
-    accessSync(existsSync3(home) ? home : dirname4(home), constants.W_OK);
+    accessSync(existsSync4(home) ? home : dirname5(home), constants.W_OK);
     homeWritable = true;
   } catch {
   }
@@ -28892,7 +28903,7 @@ __export(mcp_exports, {
 });
 import { readFileSync as readFileSync2 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 async function mcp(argv, ctx) {
   const cfg = resolveMcpConfig(argv, ctx.env, () => tokenFile(ctx.env));
   const say = (s2) => ctx.stderr(redactToken(s2, cfg.token) + "\n");
@@ -28923,9 +28934,9 @@ var init_mcp2 = __esm({
     init_server();
     init_redact();
     tokenFile = (env) => {
-      const home = env.HANOMAN_HOME ?? join5(homedir3(), ".hanoman");
+      const home = env.HANOMAN_HOME ?? join6(homedir3(), ".hanoman");
       try {
-        return readFileSync2(join5(home, "agent-token"), "utf8");
+        return readFileSync2(join6(home, "agent-token"), "utf8");
       } catch {
         return null;
       }
@@ -28945,8 +28956,8 @@ __export(migrate_pg_exports, {
   migrationSteps: () => migrationSteps,
   parseMigrateArgs: () => parseMigrateArgs
 });
-import { existsSync as existsSync4 } from "node:fs";
-import { dirname as dirname5, resolve as resolvePath2 } from "node:path";
+import { existsSync as existsSync5 } from "node:fs";
+import { dirname as dirname6, resolve as resolvePath2 } from "node:path";
 function coerceInt8(rows, fields, model) {
   const cols = fields.filter((f) => f.dataTypeID === INT8_OID).map((f) => f.name);
   if (!cols.length) return rows;
@@ -29013,8 +29024,8 @@ async function migratePg(argv, ctx) {
   let layout;
   let dbUrl;
   try {
-    layout = resolveLayout(distDir(), existsSync4);
-    dbUrl = opts.to ? `file:${resolvePath2(opts.to)}` : resolveDbUrl(ctx.env, dirname5(layout.schema));
+    layout = resolveLayout(distDir(), existsSync5);
+    dbUrl = opts.to ? `file:${resolvePath2(opts.to)}` : resolveDbUrl(ctx.env, dirname6(layout.schema));
   } catch (e) {
     ctx.stderr(`${e.message}
 `);
@@ -29152,11 +29163,11 @@ var init_migrate_pg = __esm({
 });
 
 // src/config.ts
-import { readFileSync as readFileSync3, existsSync as existsSync5 } from "node:fs";
-import { join as join6 } from "node:path";
+import { readFileSync as readFileSync3, existsSync as existsSync6 } from "node:fs";
+import { join as join7 } from "node:path";
 function loadConfig(repoRoot) {
-  const p = join6(repoRoot, "hanoman.config.json");
-  const raw = existsSync5(p) ? JSON.parse(readFileSync3(p, "utf8")) : {};
+  const p = join7(repoRoot, "hanoman.config.json");
+  const raw = existsSync6(p) ? JSON.parse(readFileSync3(p, "utf8")) : {};
   return zHanomanConfig.parse(raw);
 }
 var init_config3 = __esm({
@@ -29168,12 +29179,12 @@ var init_config3 = __esm({
 
 // src/repo.ts
 import { spawnSync } from "node:child_process";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 function resolveRepo(cwd) {
   const r = spawnSync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8" });
   const root = r.status === 0 ? r.stdout.trim() : cwd;
   const { docsDir } = loadConfig(root);
-  return { root, docsDir, indexPath: join7(root, docsDir, "README.md") };
+  return { root, docsDir, indexPath: join8(root, docsDir, "README.md") };
 }
 var init_repo = __esm({
   "src/repo.ts"() {
@@ -29184,7 +29195,7 @@ var init_repo = __esm({
 
 // src/docs-model.ts
 import { readFileSync as readFileSync4, readdirSync as readdirSync3, statSync as statSync2 } from "node:fs";
-import { join as join8, relative } from "node:path";
+import { join as join9, relative } from "node:path";
 function parseIndex(indexPath) {
   const md = readFileSync4(indexPath, "utf8");
   const out = /* @__PURE__ */ new Set();
@@ -29201,7 +29212,7 @@ function walkDocs(docsRoot) {
   const walk = (dir) => {
     for (const name of readdirSync3(dir)) {
       if (name.startsWith(".")) continue;
-      const abs = join8(dir, name);
+      const abs = join9(dir, name);
       if (statSync2(abs).isDirectory()) walk(abs);
       else out.push(relative(docsRoot, abs).split("\\").join("/"));
     }
@@ -29233,17 +29244,17 @@ var init_docs_model = __esm({
 });
 
 // src/verify.ts
-import { join as join9 } from "node:path";
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "node:fs";
+import { join as join10 } from "node:path";
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "node:fs";
 function scanCoverage(cwd) {
   const { root, docsDir, indexPath } = resolveRepo(cwd);
-  const docsRoot = join9(root, docsDir);
-  if (!existsSync6(docsRoot)) return { coverage: 100, cats: [] };
-  if (!existsSync6(indexPath)) throw new Error(`index Source of Truth tidak ada: ${indexPath}`);
+  const docsRoot = join10(root, docsDir);
+  if (!existsSync7(docsRoot)) return { coverage: 100, cats: [] };
+  if (!existsSync7(indexPath)) throw new Error(`index Source of Truth tidak ada: ${indexPath}`);
   const corpus = walkDocs(docsRoot);
   const read = (rel) => {
     try {
-      return readFileSync5(join9(docsRoot, rel), "utf8");
+      return readFileSync5(join10(docsRoot, rel), "utf8");
     } catch {
       return null;
     }
@@ -29317,23 +29328,23 @@ __export(docs_index_exports, {
   default: () => docs_index_default
 });
 import { parseArgs as parseArgs2 } from "node:util";
-import { join as join10 } from "node:path";
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "node:fs";
+import { join as join11 } from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "node:fs";
 async function docs_index_default(args, ctx) {
   const { values } = parseArgs2({ args, options: { check: { type: "boolean" }, fix: { type: "boolean" } }, allowPositionals: true });
   const { root, docsDir, indexPath } = resolveRepo(ctx.cwd);
-  const docsRoot = join10(root, docsDir);
+  const docsRoot = join11(root, docsDir);
   const corpus = walkDocs(docsRoot);
   const read = (rel) => {
     try {
-      return readFileSync7(join10(docsRoot, rel), "utf8");
+      return readFileSync7(join11(docsRoot, rel), "utf8");
     } catch {
       return null;
     }
   };
   const linked = linkedSetFrom(INDEX_NAME, corpus, read);
   const unlinked = corpus.filter((f) => f !== INDEX_NAME && !linked.has(f));
-  const dangling = [...parseIndex(indexPath)].filter((p) => !existsSync7(join10(docsRoot, p)));
+  const dangling = [...parseIndex(indexPath)].filter((p) => !existsSync8(join11(docsRoot, p)));
   if (values.fix) {
     for (const f of unlinked) addLink(indexPath, f, f.split("/")[0]);
     ctx.stdout(`linked ${unlinked.length} doc(s)
@@ -29386,7 +29397,7 @@ var init_docs_link = __esm({
 });
 
 // src/release/pack.ts
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 function packageJsonFor(version3, deps) {
   return {
     name: PKG_NAME,
@@ -29424,17 +29435,17 @@ function verifyPackedDeps(pkg) {
 }
 function copyPlan(repo) {
   return [
-    { from: join11(repo, "server/dist/server.js"), to: "dist/server.js" },
-    { from: join11(repo, "server/dist/build-info.json"), to: "dist/build-info.json" },
-    { from: join11(repo, "cli/dist/hanoman.js"), to: "dist/cli.js" },
-    { from: join11(repo, "src/dist"), to: "web", dir: true },
-    { from: join11(repo, "server/prisma/schema.prisma"), to: "prisma/schema.prisma" },
-    { from: join11(repo, "server/prisma/migrations"), to: "prisma/migrations", dir: true },
-    { from: join11(repo, "internal/docs/operations/npm-readme.md"), to: "README.md" },
+    { from: join12(repo, "server/dist/server.js"), to: "dist/server.js" },
+    { from: join12(repo, "server/dist/build-info.json"), to: "dist/build-info.json" },
+    { from: join12(repo, "cli/dist/hanoman.js"), to: "dist/cli.js" },
+    { from: join12(repo, "src/dist"), to: "web", dir: true },
+    { from: join12(repo, "server/prisma/schema.prisma"), to: "prisma/schema.prisma" },
+    { from: join12(repo, "server/prisma/migrations"), to: "prisma/migrations", dir: true },
+    { from: join12(repo, "internal/docs/operations/npm-readme.md"), to: "README.md" },
     // SPEC-489 · dibaca runtime oleh pickGuideFile (kandidat `<pkg>/docs/…`). Bukan README:
     // README paket adalah npm-readme.md (berhadapan-MANUSIA), ini naskah berhadapan-AGEN.
-    { from: join11(repo, "docs/agent-integration.md"), to: "docs/agent-integration.md" },
-    { from: join11(repo, "LICENSE"), to: "LICENSE" }
+    { from: join12(repo, "docs/agent-integration.md"), to: "docs/agent-integration.md" },
+    { from: join12(repo, "LICENSE"), to: "LICENSE" }
   ];
 }
 var PKG_NAME, REPO_URL, RUNTIME_DEPS, REQUIRED_ARTIFACTS, BIN_SHIM;
@@ -29481,10 +29492,10 @@ var pack_exports = {};
 __export(pack_exports, {
   default: () => pack
 });
-import { cpSync, existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync8, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname6, join as join12 } from "node:path";
+import { cpSync, existsSync as existsSync9, mkdirSync as mkdirSync2, readFileSync as readFileSync8, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname7, join as join13 } from "node:path";
 function depVersions(repo) {
-  const read = (p) => JSON.parse(readFileSync8(join12(repo, p), "utf8"));
+  const read = (p) => JSON.parse(readFileSync8(join13(repo, p), "utf8"));
   const server = read("server/package.json"), cli = read("cli/package.json");
   const pools = [server.dependencies, server.devDependencies, cli.dependencies, cli.devDependencies];
   const out = {};
@@ -29498,19 +29509,19 @@ function depVersions(repo) {
 async function pack(argv, ctx) {
   let repo;
   try {
-    repo = resolveLayout(distDir(), existsSync8).root;
+    repo = resolveLayout(distDir(), existsSync9).root;
   } catch (e) {
     ctx.stderr(`${e.message}
 `);
     return 1;
   }
-  if (!existsSync8(join12(repo, "server/prisma/schema.prisma"))) {
+  if (!existsSync9(join13(repo, "server/prisma/schema.prisma"))) {
     ctx.stderr("pack: hanya bisa dijalankan dari checkout repo hanoman\n");
     return 1;
   }
   const outIdx = argv.indexOf("--out");
-  const out = outIdx === -1 ? join12(repo, "dist-npm") : join12(repo, argv[outIdx + 1] ?? "dist-npm");
-  const version3 = JSON.parse(readFileSync8(join12(repo, "package.json"), "utf8")).version;
+  const out = outIdx === -1 ? join13(repo, "dist-npm") : join13(repo, argv[outIdx + 1] ?? "dist-npm");
+  const version3 = JSON.parse(readFileSync8(join13(repo, "package.json"), "utf8")).version;
   if (!version3) {
     ctx.stderr("pack: root package.json tanpa field version\n");
     return 1;
@@ -29524,20 +29535,20 @@ async function pack(argv, ctx) {
     return 1;
   }
   rmSync(out, { recursive: true, force: true });
-  mkdirSync2(join12(out, "bin"), { recursive: true });
+  mkdirSync2(join13(out, "bin"), { recursive: true });
   for (const item of copyPlan(repo)) {
-    if (!existsSync8(item.from)) {
+    if (!existsSync9(item.from)) {
       ctx.stderr(`pack: artefak hilang \u2014 ${item.from} (sudah \`pnpm build\`?)
 `);
       return 1;
     }
-    const dest = join12(out, item.to);
-    mkdirSync2(dirname6(dest), { recursive: true });
+    const dest = join13(out, item.to);
+    mkdirSync2(dirname7(dest), { recursive: true });
     cpSync(item.from, dest, item.dir ? { recursive: true } : {});
   }
-  writeFileSync2(join12(out, "bin/hanoman.mjs"), BIN_SHIM);
-  writeFileSync2(join12(out, "package.json"), JSON.stringify(packageJsonFor(version3, deps), null, 2) + "\n");
-  const missing = REQUIRED_ARTIFACTS.filter((a) => !existsSync8(join12(out, a)));
+  writeFileSync2(join13(out, "bin/hanoman.mjs"), BIN_SHIM);
+  writeFileSync2(join13(out, "package.json"), JSON.stringify(packageJsonFor(version3, deps), null, 2) + "\n");
+  const missing = REQUIRED_ARTIFACTS.filter((a) => !existsSync9(join13(out, a)));
   if (missing.length) {
     ctx.stderr(`pack: artefak wajib hilang: ${missing.join(", ")}
 `);
@@ -29563,9 +29574,9 @@ __export(verify_packed_exports, {
   default: () => verifyPacked
 });
 import { readFileSync as readFileSync9 } from "node:fs";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 function verifyPacked(_argv, ctx) {
-  const path = join13(process.cwd(), "package.json");
+  const path = join14(process.cwd(), "package.json");
   let pkg;
   try {
     pkg = JSON.parse(readFileSync9(path, "utf8"));