@vtxmacro/cli 2026.8.20 → 2026.8.22

package/bin/vtx.js

@@ -38,7 +38,7 @@ var init_agent_cli_release = __esm({
   "agent-cli-release.json"() {
     agent_cli_release_default = {
       package_name: "@vtxmacro/cli",
-      package_version: "2026.8.20",
+      package_version: "2026.8.22",
       codex_package_name: "@openai/codex",
       codex_version: "0.147.0",
       platforms: {
@@ -19837,6 +19837,9 @@ child.once('close', async () => {
         this.fatalListeners.add(listener);
         return () => this.fatalListeners.delete(listener);
       }
+      isUsable() {
+        return !this.closed && this.fatalError === null && this.process.exitCode === null;
+      }
       async readAccountSnapshot(deadlineAtMs, signal, refreshToken = false) {
         const result2 = await this.request("account/read", { refreshToken }, {
           timeoutMs: Math.max(1, deadlineAtMs - Date.now()),
@@ -20196,6 +20199,30 @@ child.once('close', async () => {
         });
         const startedAt = Date.now();
         const unsubscribe = this.subscribe(({ method, params }) => {
+          const eventThreadId = String(params.threadId || "");
+          const scopedMethod = method.startsWith("thread/") || method.startsWith("turn/") || method.startsWith("item/") || method.startsWith("rawResponse") || method === "model/rerouted";
+          if (scopedMethod && !eventThreadId) {
+            terminalReject(new CodexAppServerError({
+              message: "Codex notification omitted its thread scope.",
+              category: "adapter",
+              code: "missing_thread_notification_scope",
+              retryable: false,
+              dispatchOutcome: requestWritten ? turnId ? "confirmed_dispatched" : "outcome_unknown" : "not_dispatched"
+            }));
+            return;
+          }
+          if (scopedMethod && eventThreadId !== request.thread.threadId) {
+            if (!this.threads.has(eventThreadId)) {
+              terminalReject(new CodexAppServerError({
+                message: "Codex notification crossed thread scope.",
+                category: "adapter",
+                code: "cross_thread_notification",
+                retryable: false,
+                dispatchOutcome: turnId ? "confirmed_dispatched" : "outcome_unknown"
+              }));
+            }
+            return;
+          }
           if (forbiddenMethod(method)) {
             terminalReject(new CodexAppServerError({
               message: "Codex attempted to use forbidden child authority.",
@@ -20231,18 +20258,6 @@ child.once('close', async () => {
               return;
             }
           }
-          const eventThreadId = String(params.threadId || "");
-          const scopedMethod = method.startsWith("thread/") || method.startsWith("turn/") || method.startsWith("item/") || method.startsWith("rawResponse") || method === "model/rerouted";
-          if (scopedMethod && eventThreadId !== request.thread.threadId) {
-            terminalReject(new CodexAppServerError({
-              message: "Codex notification crossed thread scope.",
-              category: "adapter",
-              code: "cross_thread_notification",
-              retryable: false,
-              dispatchOutcome: turnId ? "confirmed_dispatched" : "outcome_unknown"
-            }));
-            return;
-          }
           const eventTurn = objectOrNull(params.turn);
           const eventTurnId = String(params.turnId || eventTurn?.id || "");
           const turnScopedMethod = method.startsWith("turn/") || method.startsWith("item/") || method.startsWith("rawResponse") || method === "model/rerouted";
@@ -20884,7 +20899,7 @@ var init_codex_adapter = __esm({
         context.addIssue({ code: "custom", message: "Codex recovery thread identity is incomplete." });
       }
       const guardianManaged = value.processToken !== null || value.processReceiptPath !== null;
-      if (value.processToken === null !== (value.processReceiptPath === null) || value.processState === "unmanaged" === guardianManaged || value.cleanupConfirmed && !["unmanaged", "terminated"].includes(value.processState)) {
+      if (value.processToken === null !== (value.processReceiptPath === null) || value.processState === "unmanaged" === guardianManaged || value.cleanupConfirmed && value.processState === "spawn_intent") {
         context.addIssue({ code: "custom", message: "Codex recovery process identity is invalid." });
       }
     });
@@ -21293,8 +21308,115 @@ var init_codex_adapter = __esm({
     CodexSubscriptionAdapter = class {
       constructor(dependencies = {}) {
         this.inFlightAttempts = /* @__PURE__ */ new Map();
+        this.attemptCleanups = /* @__PURE__ */ new Map();
+        this.durableSession = null;
+        this.durableSessionStart = null;
+        this.closing = false;
+        this.adapterClosePromise = null;
         this.dependencies = dependencies;
       }
+      async startDurableSession(codexHome, deadlineAtMs) {
+        const binary = await (this.dependencies.resolveBinary ?? resolvePinnedCodexBinary)();
+        const guardianManaged = Boolean(
+          this.dependencies.recoveryHooks && !this.dependencies.spawnProcess
+        );
+        const bootIdentity = guardianManaged ? await (this.dependencies.readBootIdentity ?? readInferenceSystemBootIdentity)() : null;
+        const processToken = guardianManaged ? randomBytes3(32).toString("hex") : null;
+        const guardianReceiptRoot = guardianManaged ? this.dependencies.guardianReceiptRoot ?? join4(tmpdir2(), "vtx-codex-guardian-receipts") : null;
+        if (guardianReceiptRoot) await ensureInferencePrivateDirectory(guardianReceiptRoot);
+        const processReceiptPath = guardianReceiptRoot && processToken ? join4(guardianReceiptRoot, `${processToken}.json`) : null;
+        const session = await CodexAppServerSession.start({
+          binary,
+          codexHome,
+          deadlineAtMs,
+          spawnProcess: this.dependencies.spawnProcess,
+          guardian: processToken && processReceiptPath ? { processToken, receiptPath: processReceiptPath, bootIdentity: bootIdentity ?? void 0 } : void 0
+        });
+        return {
+          session,
+          codexHome,
+          processToken,
+          processReceiptPath,
+          bootIdentity,
+          terminated: false,
+          closePromise: null
+        };
+      }
+      async acquireDurableSession(codexHome, deadlineAtMs, signal) {
+        if (this.closing) {
+          throw new CodexAppServerError({
+            message: "Codex adapter is closing.",
+            category: "transport",
+            code: "transport_closed",
+            retryable: true
+          });
+        }
+        if (this.durableSession && this.durableSession.codexHome === codexHome && this.durableSession.session.isUsable()) return this.durableSession;
+        if (this.durableSession && this.durableSession.codexHome !== codexHome) {
+          await this.invalidateDurableSession(this.durableSession);
+        }
+        if (this.durableSession && !this.durableSession.session.isUsable()) {
+          await this.invalidateDurableSession(this.durableSession);
+        }
+        if (!this.durableSessionStart) {
+          const start2 = this.startDurableSession(codexHome, deadlineAtMs);
+          this.durableSessionStart = start2;
+          void start2.then((session) => {
+            if (this.durableSessionStart === start2) this.durableSession = session;
+          }).finally(() => {
+            if (this.durableSessionStart === start2) this.durableSessionStart = null;
+          }).catch(() => void 0);
+        }
+        const start = this.durableSessionStart;
+        return await new Promise((resolveSession, reject) => {
+          let settled = false;
+          const finish = (callback) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+            callback();
+          };
+          const onAbort = () => finish(() => reject(new CodexAppServerError({
+            message: "Codex session acquisition was cancelled.",
+            category: "cancelled",
+            code: "cancelled",
+            retryable: false
+          })));
+          const timer = setTimeout(() => finish(() => reject(new CodexAppServerError({
+            message: "Codex session acquisition exceeded the immutable deadline.",
+            category: "timeout",
+            code: "deadline_exceeded",
+            retryable: false
+          }))), Math.max(1, deadlineAtMs - Date.now()));
+          signal?.addEventListener("abort", onAbort, { once: true });
+          if (signal?.aborted) {
+            onAbort();
+            return;
+          }
+          void start.then(
+            (session) => finish(() => resolveSession(session)),
+            (error48) => finish(() => reject(error48))
+          );
+        });
+      }
+      async invalidateDurableSession(session) {
+        if (this.durableSession === session) this.durableSession = null;
+        if (!session.closePromise) {
+          session.closePromise = (async () => {
+            await session.session.close();
+            if (session.processToken && session.processReceiptPath) {
+              await waitForCodexGuardianState(
+                { processToken: session.processToken, receiptPath: session.processReceiptPath },
+                "terminated",
+                Date.now() + 5e3
+              );
+            }
+            session.terminated = true;
+          })();
+        }
+        await session.closePromise;
+      }
       runAttempt(input) {
         const active = this.inFlightAttempts.get(input.attemptId);
         if (active) {
@@ -21309,15 +21431,21 @@ var init_codex_adapter = __esm({
           }
           return active.promise;
         }
-        const promise2 = this.executeAttempt(input).finally(() => {
-          if (this.inFlightAttempts.get(input.attemptId)?.promise === promise2) {
-            this.inFlightAttempts.delete(input.attemptId);
-          }
-        });
+        const promise2 = this.executeAttempt(input);
         this.inFlightAttempts.set(input.attemptId, {
           inputSha256: input.inputSha256,
           promise: promise2
         });
+        void promise2.then(async () => {
+          await this.attemptCleanups.get(input.attemptId)?.catch(() => void 0);
+          if (this.inFlightAttempts.get(input.attemptId)?.promise === promise2) {
+            this.inFlightAttempts.delete(input.attemptId);
+          }
+        }, () => {
+          if (this.inFlightAttempts.get(input.attemptId)?.promise === promise2) {
+            this.inFlightAttempts.delete(input.attemptId);
+          }
+        }).catch(() => void 0);
         return promise2;
       }
       async acknowledgeAttempt(attemptId) {
@@ -21329,8 +21457,27 @@ var init_codex_adapter = __esm({
             retryable: false
           });
         }
+        const activeCleanup = this.attemptCleanups.get(attemptId);
+        if (activeCleanup) {
+          try {
+            await activeCleanup;
+          } catch (error48) {
+            throw new CodexAppServerError({
+              message: "Codex attempt cleanup could not be confirmed.",
+              category: "adapter",
+              code: "attempt_cleanup_unconfirmed",
+              retryable: false,
+              cause: error48
+            });
+          }
+        }
         const recoveryHooks = this.dependencies.recoveryHooks;
-        if (!recoveryHooks) return;
+        if (!recoveryHooks) {
+          if (activeCleanup && this.attemptCleanups.get(attemptId) === activeCleanup) {
+            this.attemptCleanups.delete(attemptId);
+          }
+          return;
+        }
         const checkpoint = await recoveryHooks.load(attemptId);
         if (checkpoint && !checkpoint.cleanupConfirmed) {
           throw new CodexAppServerError({
@@ -21352,9 +21499,60 @@ var init_codex_adapter = __esm({
               dispatchOutcome: checkpoint.dispatchOutcome
             });
           }
-          await rm3(checkpoint.processReceiptPath, { force: true });
+          const receipt = await readCodexGuardianReceipt(checkpoint.processReceiptPath);
+          if (checkpoint.processState === "terminated" || receipt === null || receipt.state === "terminated") {
+            await rm3(checkpoint.processReceiptPath, { force: true });
+          }
         }
         await recoveryHooks.clear(attemptId);
+        if (activeCleanup && this.attemptCleanups.get(attemptId) === activeCleanup) {
+          this.attemptCleanups.delete(attemptId);
+        }
+      }
+      async close() {
+        if (!this.adapterClosePromise) {
+          this.closing = true;
+          this.adapterClosePromise = (async () => {
+            const sessions = /* @__PURE__ */ new Set();
+            if (this.durableSession) sessions.add(this.durableSession);
+            const starting = this.durableSessionStart;
+            if (starting) {
+              const started = await starting.catch(() => null);
+              if (started) sessions.add(started);
+            }
+            await Promise.all(
+              [...sessions].map((session) => this.invalidateDurableSession(session))
+            );
+            await Promise.allSettled(
+              [...this.inFlightAttempts.values()].map((attempt) => attempt.promise)
+            );
+            await Promise.allSettled(
+              [...this.attemptCleanups.values()]
+            );
+            let unconfirmedReceiptPaths = /* @__PURE__ */ new Set();
+            const recoveryHooks = this.dependencies.recoveryHooks;
+            if (recoveryHooks) {
+              if (!recoveryHooks.loadAll) {
+                unconfirmedReceiptPaths = null;
+              } else {
+                try {
+                  const checkpoints = await recoveryHooks.loadAll();
+                  unconfirmedReceiptPaths = new Set(
+                    Object.values(checkpoints).filter((checkpoint) => !checkpoint.cleanupConfirmed && checkpoint.processReceiptPath !== null).map((checkpoint) => resolve3(checkpoint.processReceiptPath))
+                  );
+                } catch {
+                  unconfirmedReceiptPaths = null;
+                }
+              }
+            }
+            for (const session of sessions) {
+              if (session.processReceiptPath && unconfirmedReceiptPaths !== null && !unconfirmedReceiptPaths.has(resolve3(session.processReceiptPath))) {
+                await rm3(session.processReceiptPath, { force: true });
+              }
+            }
+          })();
+        }
+        await this.adapterClosePromise;
       }
       async executeAttempt(input) {
         const validatedInput = validateAttemptInput(input);
@@ -21406,6 +21604,7 @@ var init_codex_adapter = __esm({
           });
         }
         let resources = null;
+        let sessionLease = null;
         let session = null;
         let threadId = null;
         let baseCheckpoint = null;
@@ -21413,22 +21612,20 @@ var init_codex_adapter = __esm({
         let currentDispatchOutcome = "not_dispatched";
         let completedResult = null;
         let caughtError = null;
+        let sessionInvalidationError = null;
         try {
-          const binary = await (this.dependencies.resolveBinary ?? resolvePinnedCodexBinary)();
           resources = await (this.dependencies.createAttemptResources ?? ((attemptId) => createIsolatedCodexAttemptResources(
             attemptId,
             this.dependencies.codexHome
           )))(input.attemptId);
           await access2(resources.codexHome, fsConstants2.R_OK | fsConstants2.W_OK);
           await access2(resources.workspacePath, fsConstants2.R_OK);
-          const guardianManaged = Boolean(recoveryHooks && !this.dependencies.spawnProcess);
-          const bootIdentity = guardianManaged ? await (this.dependencies.readBootIdentity ?? readInferenceSystemBootIdentity)() : null;
-          const processToken = guardianManaged ? randomBytes3(32).toString("hex") : null;
-          const guardianReceiptRoot = guardianManaged ? this.dependencies.guardianReceiptRoot ?? join4(tmpdir2(), "vtx-codex-guardian-receipts") : null;
-          if (guardianReceiptRoot) {
-            await ensureInferencePrivateDirectory(guardianReceiptRoot);
-          }
-          const processReceiptPath = guardianReceiptRoot && processToken ? join4(guardianReceiptRoot, `${processToken}.json`) : null;
+          sessionLease = await this.acquireDurableSession(
+            resources.codexHome,
+            input.deadlineAtMs,
+            input.signal
+          );
+          session = sessionLease.session;
           baseCheckpoint = {
             schemaVersion: "vtx_codex_attempt_recovery_v1",
             attemptId: input.attemptId,
@@ -21438,10 +21635,10 @@ var init_codex_adapter = __esm({
             workspacePath: resources.workspacePath,
             threadId: null,
             threadPath: null,
-            processToken,
-            processReceiptPath,
-            processState: guardianManaged ? "spawn_intent" : "unmanaged",
-            bootIdentity,
+            processToken: sessionLease.processToken,
+            processReceiptPath: sessionLease.processReceiptPath,
+            processState: sessionLease.processToken ? "running" : "unmanaged",
+            bootIdentity: sessionLease.bootIdentity,
             cleanupConfirmed: false,
             adapterRequestId: null,
             adapterResponseId: null,
@@ -21450,19 +21647,6 @@ var init_codex_adapter = __esm({
           };
           latestCheckpoint = baseCheckpoint;
           await recoveryHooks?.save(baseCheckpoint);
-          session = await CodexAppServerSession.start({
-            binary,
-            codexHome: resources.codexHome,
-            deadlineAtMs: input.deadlineAtMs,
-            signal: input.signal,
-            spawnProcess: this.dependencies.spawnProcess,
-            guardian: processToken && processReceiptPath ? { processToken, receiptPath: processReceiptPath, bootIdentity: bootIdentity ?? void 0 } : void 0
-          });
-          if (guardianManaged) {
-            baseCheckpoint = { ...baseCheckpoint, processState: "running" };
-            latestCheckpoint = baseCheckpoint;
-            await recoveryHooks?.save(baseCheckpoint);
-          }
           await session.requireManagedChatGptAuth(input.deadlineAtMs, input.signal);
           await session.requireModel(
             input.requestedModel,
@@ -21517,11 +21701,23 @@ var init_codex_adapter = __esm({
             terminal: { kind: "completed", result: result2 }
           };
           await recoveryHooks?.save(latestCheckpoint);
-          await session.deleteThread(thread.threadId);
-          threadId = null;
           return result2;
         } catch (error48) {
           caughtError = error48;
+          if (sessionLease && (!sessionLease.session.isUsable() || error48 instanceof CodexAppServerError && (error48.category === "transport" || [
+            "rpc_rejected",
+            "invalid_rpc_result",
+            "rpc_timeout",
+            "invalid_thread_provenance",
+            "thread_cleanup_identity_missing",
+            "thread_delete_unconfirmed"
+          ].includes(error48.code)))) {
+            try {
+              await this.invalidateDurableSession(sessionLease);
+            } catch (invalidationError) {
+              sessionInvalidationError = invalidationError;
+            }
+          }
           if (error48 instanceof CodexAppServerError) {
             const dispatchOutcome = error48.dispatchOutcome === "not_dispatched" ? currentDispatchOutcome : error48.dispatchOutcome;
             if (baseCheckpoint && !completedResult) {
@@ -21584,64 +21780,63 @@ var init_codex_adapter = __esm({
           }
           throw classified;
         } finally {
-          let cleanupError = null;
-          if (session && threadId) {
-            try {
-              await session.deleteThread(threadId);
-            } catch (error48) {
-              cleanupError = error48;
+          const cleanup = async () => {
+            let cleanupError = sessionInvalidationError;
+            if (session && threadId) {
+              try {
+                await session.deleteThread(threadId);
+              } catch (error48) {
+                cleanupError = error48;
+              }
             }
-          }
-          try {
-            await session?.close();
-          } catch (error48) {
-            cleanupError ??= error48;
-          }
-          if (latestCheckpoint && recoveryHooks) {
-            try {
-              if (latestCheckpoint.processToken && latestCheckpoint.processReceiptPath) {
-                await waitForCodexGuardianState(
-                  {
-                    processToken: latestCheckpoint.processToken,
-                    receiptPath: latestCheckpoint.processReceiptPath
-                  },
-                  "terminated",
-                  Date.now() + 5e3
-                );
+            if (sessionLease && cleanupError) {
+              try {
+                await this.invalidateDurableSession(sessionLease);
+              } catch (error48) {
+                cleanupError ??= error48;
               }
-            } catch (error48) {
-              cleanupError ??= error48;
             }
-          }
-          if (resources && cleanupError === null) {
-            try {
-              await resources.cleanup();
-            } catch (error48) {
-              cleanupError = error48;
+            if (resources && cleanupError === null) {
+              try {
+                await resources.cleanup();
+              } catch (error48) {
+                cleanupError = error48;
+              }
             }
-          }
-          if (latestCheckpoint && recoveryHooks && cleanupError === null) {
-            latestCheckpoint = {
-              ...latestCheckpoint,
-              processState: latestCheckpoint.processToken ? "terminated" : "unmanaged",
-              cleanupConfirmed: true
-            };
+            if (latestCheckpoint && recoveryHooks && cleanupError === null) {
+              latestCheckpoint = {
+                ...latestCheckpoint,
+                processState: latestCheckpoint.processToken ? sessionLease?.terminated ? "terminated" : "running" : "unmanaged",
+                cleanupConfirmed: true
+              };
+              try {
+                await recoveryHooks.save(latestCheckpoint);
+              } catch (error48) {
+                cleanupError = error48;
+              }
+            }
+            if (cleanupError) {
+              throw new CodexAppServerError({
+                message: "Codex attempt cleanup could not be confirmed.",
+                category: "adapter",
+                code: "attempt_cleanup_unconfirmed",
+                retryable: false,
+                dispatchOutcome: currentDispatchOutcome,
+                cause: cleanupError
+              });
+            }
+          };
+          if (completedResult && caughtError === null) {
+            const cleanupPromise = cleanup();
+            void cleanupPromise.catch(() => void 0);
+            this.attemptCleanups.set(input.attemptId, cleanupPromise);
+          } else {
             try {
-              await recoveryHooks.save(latestCheckpoint);
+              await cleanup();
             } catch (error48) {
-              cleanupError = error48;
+              if (caughtError === null) throw error48;
             }
           }
-          if (cleanupError && caughtError === null) {
-            throw new CodexAppServerError({
-              message: "Codex attempt cleanup could not be confirmed.",
-              category: "adapter",
-              code: "attempt_cleanup_unconfirmed",
-              retryable: false,
-              dispatchOutcome: currentDispatchOutcome,
-              cause: cleanupError
-            });
-          }
         }
       }
     };
@@ -29377,7 +29572,11 @@ var init_runner = __esm({
         } finally {
           removeAbortListener();
           unregisterSignals();
-          await lock2.release();
+          try {
+            await this.dependencies.codexAdapter.close?.();
+          } finally {
+            await lock2.release();
+          }
         }
       }
       async persistReceipt(receipt, now) {
@@ -30382,11 +30581,18 @@ ${result2.stderr}`)) {
       const startedAt = Date.now();
       const log = createWriteStream(manifest.log_path, { flags: "a", mode: 384 });
       return await new Promise((resolvePromise, reject) => {
+        let stdout = "";
         const child = spawn5(manifest.executable, args, {
           env: { ...process.env, ...manifest.runtime_environment },
           windowsHide: true,
-          stdio: ["ignore", log, log]
+          stdio: ["ignore", "pipe", "pipe"]
         });
+        child.stdout.on("data", (chunk) => {
+          const text = chunk.toString("utf8");
+          log.write(text);
+          stdout = `${stdout}${text}`.slice(-65536);
+        });
+        child.stderr.on("data", (chunk) => log.write(chunk));
         const onAbort = () => child.kill("SIGTERM");
         signal.addEventListener("abort", onAbort, { once: true });
         child.once("error", (error48) => {
@@ -30397,7 +30603,24 @@ ${result2.stderr}`)) {
         child.once("exit", (code) => {
           signal.removeEventListener("abort", onAbort);
           log.end();
-          resolvePromise({ exitCode: code ?? 1, uptimeMs: Date.now() - startedAt });
+          let drainReason = null;
+          for (const line of stdout.trim().split("\n").reverse()) {
+            try {
+              const parsed = JSON.parse(line);
+              if (parsed && typeof parsed === "object" && !Array.isArray(parsed) && typeof parsed.drain_reason === "string" && /^[a-z0-9_]{1,96}$/u.test(
+                parsed.drain_reason
+              )) {
+                drainReason = parsed.drain_reason;
+                break;
+              }
+            } catch {
+            }
+          }
+          resolvePromise({
+            exitCode: code ?? 1,
+            uptimeMs: Date.now() - startedAt,
+            drainReason
+          });
         });
       });
     };
@@ -30447,6 +30670,7 @@ ${result2.stderr}`)) {
           await appendServiceLog(manifest.log_path, "worker_exited", {
             exit_code: result2.exitCode,
             uptime_ms: result2.uptimeMs,
+            drain_reason: result2.drainReason ?? null,
             retry_after_ms: retryAfterMs
           });
           await sleep4(retryAfterMs);
@@ -31932,7 +32156,21 @@ Waiting for approval...
                   ...dependencies,
                   registerLifecycleSignalHandlers: unregister
                 }, warnings);
-                return { exitCode: result2.exitCode, uptimeMs: Date.now() - startedAt };
+                let drainReason = null;
+                try {
+                  const summary = JSON.parse(result2.stdout);
+                  if (summary && typeof summary === "object" && !Array.isArray(summary) && typeof summary.drain_reason === "string" && /^[a-z0-9_]{1,96}$/u.test(
+                    summary.drain_reason
+                  )) {
+                    drainReason = summary.drain_reason;
+                  }
+                } catch {
+                }
+                return {
+                  exitCode: result2.exitCode,
+                  uptimeMs: Date.now() - startedAt,
+                  drainReason
+                };
               }
             }
           );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vtxmacro/cli",
-  "version": "2026.8.20",
+  "version": "2026.8.22",
   "description": "VTX Macro CLI, MCP server, and durable subscription inference host.",
   "type": "module",
   "license": "UNLICENSED",