@prismshadow/penguin-server 0.2.13 → 0.2.15

package/dist/api/types.js

@@ -1,8 +1,10 @@
 import {
+  MACHINE_PHASES,
   TICKET_SLUG_PATTERN
-} from "../chunk-L2H3K4DT.js";
+} from "../chunk-JKJXQTHH.js";
 import "../chunk-B5IP37ZQ.js";
 export {
+  MACHINE_PHASES,
   TICKET_SLUG_PATTERN
 };
 //# sourceMappingURL=types.js.map

package/dist/auth-token.d.ts

@@ -1,3 +1,6 @@
+/** How a session was established, as stored. NULL on rows formed before the column existed. */
+type SessionViaValue = "password" | "desktop" | "setup" | "cli";
+
 /** An hour: long enough for a controller to finish, short enough to forget. */
 declare const CLI_TOKEN_TTL_MS: number;
 /**
@@ -5,6 +8,22 @@ declare const CLI_TOKEN_TTL_MS: number;
  * a token that lives in a file must not outlive an ordinary browser session.
  */
 declare const CLI_TOKEN_MAX_TTL_MS: number;
+/**
+ * What a minted row records about how its session was established.
+ *
+ * `cli` is the default and what `penguin auth token` writes: a session that behaves like a
+ * password one in every way. `desktop` is for the desktop shell signing its own window in
+ * against a server it did not spawn, and says the same thing its one-shot claim token says —
+ * with as much backing, since only an account that can write this file can mint at all.
+ *
+ * The distinction is not cosmetic: a desktop session may set a password without supplying the
+ * current one, because the account the shell created has a password that was generated,
+ * hashed and discarded unseen — there is nothing to supply, and whoever can write to this
+ * data root can already reset that password offline (`penguin server reset-admin-password`).
+ * That allowance is granted by a server running in desktop mode; against any other server the
+ * value records what the session is without widening what it may do (routes/me.ts).
+ */
+type MintedVia = Extract<SessionViaValue, "cli" | "desktop">;
 type MintTokenResult = {
     outcome: "minted";
     token: string;
@@ -24,6 +43,8 @@ declare function mintApiToken(root: string, opts?: {
     ttlMs?: number;
     dbPath?: string;
     now?: Date;
+    /** How the session records its own establishment; `cli` unless told otherwise. */
+    via?: MintedVia;
 }): MintTokenResult;
 
-export { CLI_TOKEN_MAX_TTL_MS, CLI_TOKEN_TTL_MS, type MintTokenResult, mintApiToken };
+export { CLI_TOKEN_MAX_TTL_MS, CLI_TOKEN_TTL_MS, type MintTokenResult, type MintedVia, mintApiToken };

package/dist/auth-token.js

@@ -4,7 +4,7 @@ import {
 } from "./chunk-TOOTEEM4.js";
 import {
   openExistingDatabase
-} from "./chunk-A3QANMU5.js";
+} from "./chunk-NVWAYYRX.js";
 import "./chunk-B5IP37ZQ.js";
 
 // src/auth-token.ts
@@ -35,7 +35,7 @@ function mintApiToken(root, opts = {}) {
     }
     const { token, expiresAt } = wire(AuthSessionsRepo, { db }).issue({
       userId,
-      via: "cli",
+      via: opts.via ?? "cli",
       now: opts.now ?? /* @__PURE__ */ new Date(),
       ttlMs: opts.ttlMs ?? CLI_TOKEN_TTL_MS,
       maxTtlMs: CLI_TOKEN_MAX_TTL_MS

package/dist/auth-token.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/auth-token.ts"],"sourcesContent":["/**\n * Mints an API session by inserting a row into the root's `web.db` — no running server needed.\n * Authorized by being able to read and write that root, which already holds every credential\n * the token could reach. On a multi-user box that means the OS account running the server;\n * everyone else signs in with `penguin auth login --server <url>`.\n */\nimport path from \"node:path\";\nimport fs from \"node:fs\";\nimport { openExistingDatabase } from \"./db/database.js\";\nimport { AuthSessionsRepo } from \"./db/repos/auth-sessions.js\";\nimport { UsersRepo } from \"./db/repos/users.js\";\nimport { wire } from \"@prismshadow/penguin-core/kernel\";\n\n/** An hour: long enough for a controller to finish, short enough to forget. */\nexport const CLI_TOKEN_TTL_MS = 60 * 60_000;\n\n/**\n * Ceiling on a caller-supplied `--ttl-seconds`, matching the default session TTL (config.ts):\n * a token that lives in a file must not outlive an ordinary browser session.\n */\nexport const CLI_TOKEN_MAX_TTL_MS = 30 * 24 * 60 * 60_000;\n\nexport type MintTokenResult =\n  | { outcome: \"minted\"; token: string; userId: string; expiresAt: string }\n  /** No web.db on this root — the server has never run here, so there is no account to mint for. */\n  | { outcome: \"no_server\" }\n  | { outcome: \"failed\"; detail: string };\n\n/**\n * Turns a failure into something the person at the terminal can act on. Both cases are\n * ordinary situations, not crashes: a database owned by another OS account, and one written\n * by an older release (minting deliberately does not migrate — see openExistingDatabase).\n */\nfunction explain(err: unknown, dbPath: string): string {\n  const message = err instanceof Error ? err.message : String(err);\n  if (message.includes(\"no column named via\")) {\n    return `${dbPath} predates this release — start the server once (\\`penguin web\\`) to upgrade it`;\n  }\n  if (message.includes(\"unable to open database\")) {\n    return (\n      `cannot open ${dbPath} — minting needs the data root's own OS account; ` +\n      \"otherwise sign in with `penguin auth login --server <url>`\"\n    );\n  }\n  return message;\n}\n\n/** Issues an API session token for the data root at `root`. */\nexport function mintApiToken(\n  root: string,\n  opts: { userId?: string; ttlMs?: number; dbPath?: string; now?: Date } = {},\n): MintTokenResult {\n  const userId = opts.userId ?? \"admin\";\n  const dbPath = opts.dbPath ?? path.join(root, \"web.db\");\n  // Existence check first: openExistingDatabase would otherwise create an empty file, and a\n  // root with no web.db has no account to mint for.\n  if (!fs.existsSync(dbPath)) return { outcome: \"no_server\" };\n\n  let db: ReturnType<typeof openExistingDatabase> | null = null;\n  try {\n    db = openExistingDatabase(dbPath);\n    if (wire(UsersRepo, { db: db }).findById(userId) === null) {\n      return { outcome: \"failed\", detail: `no such account: ${userId}` };\n    }\n    // The repo is the single minting point (token shape, hash, TTL ceiling), so a CLI-minted\n    // row cannot drift from one the server issues itself.\n    const { token, expiresAt } = wire(AuthSessionsRepo, { db: db }).issue({\n      userId,\n      via: \"cli\",\n      now: opts.now ?? new Date(),\n      ttlMs: opts.ttlMs ?? CLI_TOKEN_TTL_MS,\n      maxTtlMs: CLI_TOKEN_MAX_TTL_MS,\n    });\n    return { outcome: \"minted\", token, userId, expiresAt };\n  } catch (err) {\n    return { outcome: \"failed\", detail: explain(err, dbPath) };\n  } finally {\n    db?.close();\n  }\n}\n"],"mappings":";;;;;;;;;;AAMA,OAAO,UAAU;AACjB,OAAO,QAAQ;AAIf,SAAS,YAAY;AAGd,IAAM,mBAAmB,KAAK;AAM9B,IAAM,uBAAuB,KAAK,KAAK,KAAK;AAanD,SAAS,QAAQ,KAAc,QAAwB;AACrD,QAAM,UAAU,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;AAC/D,MAAI,QAAQ,SAAS,qBAAqB,GAAG;AAC3C,WAAO,GAAG,MAAM;AAAA,EAClB;AACA,MAAI,QAAQ,SAAS,yBAAyB,GAAG;AAC/C,WACE,eAAe,MAAM;AAAA,EAGzB;AACA,SAAO;AACT;AAGO,SAAS,aACd,MACA,OAAyE,CAAC,GACzD;AACjB,QAAM,SAAS,KAAK,UAAU;AAC9B,QAAM,SAAS,KAAK,UAAU,KAAK,KAAK,MAAM,QAAQ;AAGtD,MAAI,CAAC,GAAG,WAAW,MAAM,EAAG,QAAO,EAAE,SAAS,YAAY;AAE1D,MAAI,KAAqD;AACzD,MAAI;AACF,SAAK,qBAAqB,MAAM;AAChC,QAAI,KAAK,WAAW,EAAE,GAAO,CAAC,EAAE,SAAS,MAAM,MAAM,MAAM;AACzD,aAAO,EAAE,SAAS,UAAU,QAAQ,oBAAoB,MAAM,GAAG;AAAA,IACnE;AAGA,UAAM,EAAE,OAAO,UAAU,IAAI,KAAK,kBAAkB,EAAE,GAAO,CAAC,EAAE,MAAM;AAAA,MACpE;AAAA,MACA,KAAK;AAAA,MACL,KAAK,KAAK,OAAO,oBAAI,KAAK;AAAA,MAC1B,OAAO,KAAK,SAAS;AAAA,MACrB,UAAU;AAAA,IACZ,CAAC;AACD,WAAO,EAAE,SAAS,UAAU,OAAO,QAAQ,UAAU;AAAA,EACvD,SAAS,KAAK;AACZ,WAAO,EAAE,SAAS,UAAU,QAAQ,QAAQ,KAAK,MAAM,EAAE;AAAA,EAC3D,UAAE;AACA,QAAI,MAAM;AAAA,EACZ;AACF;","names":[]}
+{"version":3,"sources":["../src/auth-token.ts"],"sourcesContent":["/**\n * Mints an API session by inserting a row into the root's `web.db` — no running server needed.\n * Authorized by being able to read and write that root, which already holds every credential\n * the token could reach. On a multi-user box that means the OS account running the server;\n * everyone else signs in with `penguin auth login --server <url>`.\n */\nimport path from \"node:path\";\nimport fs from \"node:fs\";\nimport { openExistingDatabase } from \"./db/database.js\";\nimport { AuthSessionsRepo } from \"./db/repos/auth-sessions.js\";\nimport type { SessionViaValue } from \"./db/repos/auth-sessions.js\";\nimport { UsersRepo } from \"./db/repos/users.js\";\nimport { wire } from \"@prismshadow/penguin-core/kernel\";\n\n/** An hour: long enough for a controller to finish, short enough to forget. */\nexport const CLI_TOKEN_TTL_MS = 60 * 60_000;\n\n/**\n * Ceiling on a caller-supplied `--ttl-seconds`, matching the default session TTL (config.ts):\n * a token that lives in a file must not outlive an ordinary browser session.\n */\nexport const CLI_TOKEN_MAX_TTL_MS = 30 * 24 * 60 * 60_000;\n\n/**\n * What a minted row records about how its session was established.\n *\n * `cli` is the default and what `penguin auth token` writes: a session that behaves like a\n * password one in every way. `desktop` is for the desktop shell signing its own window in\n * against a server it did not spawn, and says the same thing its one-shot claim token says —\n * with as much backing, since only an account that can write this file can mint at all.\n *\n * The distinction is not cosmetic: a desktop session may set a password without supplying the\n * current one, because the account the shell created has a password that was generated,\n * hashed and discarded unseen — there is nothing to supply, and whoever can write to this\n * data root can already reset that password offline (`penguin server reset-admin-password`).\n * That allowance is granted by a server running in desktop mode; against any other server the\n * value records what the session is without widening what it may do (routes/me.ts).\n */\nexport type MintedVia = Extract<SessionViaValue, \"cli\" | \"desktop\">;\n\nexport type MintTokenResult =\n  | { outcome: \"minted\"; token: string; userId: string; expiresAt: string }\n  /** No web.db on this root — the server has never run here, so there is no account to mint for. */\n  | { outcome: \"no_server\" }\n  | { outcome: \"failed\"; detail: string };\n\n/**\n * Turns a failure into something the person at the terminal can act on. Both cases are\n * ordinary situations, not crashes: a database owned by another OS account, and one written\n * by an older release (minting deliberately does not migrate — see openExistingDatabase).\n */\nfunction explain(err: unknown, dbPath: string): string {\n  const message = err instanceof Error ? err.message : String(err);\n  if (message.includes(\"no column named via\")) {\n    return `${dbPath} predates this release — start the server once (\\`penguin web\\`) to upgrade it`;\n  }\n  if (message.includes(\"unable to open database\")) {\n    return (\n      `cannot open ${dbPath} — minting needs the data root's own OS account; ` +\n      \"otherwise sign in with `penguin auth login --server <url>`\"\n    );\n  }\n  return message;\n}\n\n/** Issues an API session token for the data root at `root`. */\nexport function mintApiToken(\n  root: string,\n  opts: {\n    userId?: string;\n    ttlMs?: number;\n    dbPath?: string;\n    now?: Date;\n    /** How the session records its own establishment; `cli` unless told otherwise. */\n    via?: MintedVia;\n  } = {},\n): MintTokenResult {\n  const userId = opts.userId ?? \"admin\";\n  const dbPath = opts.dbPath ?? path.join(root, \"web.db\");\n  // Existence check first: openExistingDatabase would otherwise create an empty file, and a\n  // root with no web.db has no account to mint for.\n  if (!fs.existsSync(dbPath)) return { outcome: \"no_server\" };\n\n  let db: ReturnType<typeof openExistingDatabase> | null = null;\n  try {\n    db = openExistingDatabase(dbPath);\n    if (wire(UsersRepo, { db: db }).findById(userId) === null) {\n      return { outcome: \"failed\", detail: `no such account: ${userId}` };\n    }\n    // The repo is the single minting point (token shape, hash, TTL ceiling), so a CLI-minted\n    // row cannot drift from one the server issues itself.\n    const { token, expiresAt } = wire(AuthSessionsRepo, { db: db }).issue({\n      userId,\n      via: opts.via ?? \"cli\",\n      now: opts.now ?? new Date(),\n      ttlMs: opts.ttlMs ?? CLI_TOKEN_TTL_MS,\n      maxTtlMs: CLI_TOKEN_MAX_TTL_MS,\n    });\n    return { outcome: \"minted\", token, userId, expiresAt };\n  } catch (err) {\n    return { outcome: \"failed\", detail: explain(err, dbPath) };\n  } finally {\n    db?.close();\n  }\n}\n"],"mappings":";;;;;;;;;;AAMA,OAAO,UAAU;AACjB,OAAO,QAAQ;AAKf,SAAS,YAAY;AAGd,IAAM,mBAAmB,KAAK;AAM9B,IAAM,uBAAuB,KAAK,KAAK,KAAK;AA8BnD,SAAS,QAAQ,KAAc,QAAwB;AACrD,QAAM,UAAU,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;AAC/D,MAAI,QAAQ,SAAS,qBAAqB,GAAG;AAC3C,WAAO,GAAG,MAAM;AAAA,EAClB;AACA,MAAI,QAAQ,SAAS,yBAAyB,GAAG;AAC/C,WACE,eAAe,MAAM;AAAA,EAGzB;AACA,SAAO;AACT;AAGO,SAAS,aACd,MACA,OAOI,CAAC,GACY;AACjB,QAAM,SAAS,KAAK,UAAU;AAC9B,QAAM,SAAS,KAAK,UAAU,KAAK,KAAK,MAAM,QAAQ;AAGtD,MAAI,CAAC,GAAG,WAAW,MAAM,EAAG,QAAO,EAAE,SAAS,YAAY;AAE1D,MAAI,KAAqD;AACzD,MAAI;AACF,SAAK,qBAAqB,MAAM;AAChC,QAAI,KAAK,WAAW,EAAE,GAAO,CAAC,EAAE,SAAS,MAAM,MAAM,MAAM;AACzD,aAAO,EAAE,SAAS,UAAU,QAAQ,oBAAoB,MAAM,GAAG;AAAA,IACnE;AAGA,UAAM,EAAE,OAAO,UAAU,IAAI,KAAK,kBAAkB,EAAE,GAAO,CAAC,EAAE,MAAM;AAAA,MACpE;AAAA,MACA,KAAK,KAAK,OAAO;AAAA,MACjB,KAAK,KAAK,OAAO,oBAAI,KAAK;AAAA,MAC1B,OAAO,KAAK,SAAS;AAAA,MACrB,UAAU;AAAA,IACZ,CAAC;AACD,WAAO,EAAE,SAAS,UAAU,OAAO,QAAQ,UAAU;AAAA,EACvD,SAAS,KAAK;AACZ,WAAO,EAAE,SAAS,UAAU,QAAQ,QAAQ,KAAK,MAAM,EAAE;AAAA,EAC3D,UAAE;AACA,QAAI,MAAM;AAAA,EACZ;AACF;","names":[]}

package/dist/benchmark-package.d.ts

@@ -0,0 +1,39 @@
+/** Why a path cannot go up as a Benchmark package; the caller words it. */
+type BenchmarkUploadProblem = {
+    kind: "missing";
+}
+/** Neither a folder nor a file. */
+ | {
+    kind: "unsupported";
+} | {
+    kind: "tooManyFiles";
+    limit: number;
+}
+/** `file` is the entry's path inside the folder. */
+ | {
+    kind: "fileTooLarge";
+    file: string;
+    limitBytes: number;
+}
+/** The folder's files add up to more than the package may hold. */
+ | {
+    kind: "tooLarge";
+    limitBytes: number;
+}
+/** The zip, given or made, is larger than an upload may be. */
+ | {
+    kind: "zipTooLarge";
+    limitBytes: number;
+};
+declare class BenchmarkUploadError extends Error {
+    readonly problem: BenchmarkUploadProblem;
+    constructor(problem: BenchmarkUploadProblem);
+}
+/**
+ * The bytes to upload for `source`: the zip file itself, or the folder zipped as the module doc
+ * says. Throws BenchmarkUploadError for a path that cannot go up (nothing there, past a cap), and
+ * whatever the filesystem throws for a path it cannot read.
+ */
+declare function readBenchmarkUpload(source: string): Promise<Uint8Array>;
+
+export { BenchmarkUploadError, type BenchmarkUploadProblem, readBenchmarkUpload };

package/dist/benchmark-package.js

@@ -0,0 +1,97 @@
+import {
+  MAX_ARCHIVE_BYTES,
+  MAX_BENCHMARK_ARCHIVE_FILES,
+  MAX_FILE_BYTES,
+  MAX_TOTAL_BYTES
+} from "./chunk-54E64LWB.js";
+import "./chunk-Q4ON2L6E.js";
+import "./chunk-B5IP37ZQ.js";
+
+// src/benchmark-package.ts
+import fs from "fs/promises";
+import path from "path";
+import { strToU8, zipSync } from "fflate";
+var BenchmarkUploadError = class extends Error {
+  constructor(problem) {
+    super(`Not a Benchmark package upload: ${problem.kind}`);
+    this.problem = problem;
+    this.name = "BenchmarkUploadError";
+  }
+  problem;
+};
+var UNIX_HOST = 3;
+function specialMode(entry) {
+  if (entry.isSymbolicLink()) return 41471;
+  if (entry.isSocket()) return 49572;
+  if (entry.isBlockDevice()) return 24996;
+  if (entry.isCharacterDevice()) return 8612;
+  return 4516;
+}
+function byName(a, b) {
+  return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+}
+async function readBenchmarkUpload(source) {
+  let stat;
+  try {
+    stat = await fs.stat(source);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new BenchmarkUploadError({ kind: "missing" });
+    }
+    throw error;
+  }
+  const zipTooLarge = () => new BenchmarkUploadError({ kind: "zipTooLarge", limitBytes: MAX_ARCHIVE_BYTES });
+  if (stat.isFile()) {
+    if (stat.size > MAX_ARCHIVE_BYTES) throw zipTooLarge();
+    return new Uint8Array(await fs.readFile(source));
+  }
+  if (!stat.isDirectory()) throw new BenchmarkUploadError({ kind: "unsupported" });
+  const files = {};
+  let count = 0;
+  let total = 0;
+  const walk = async (dir, prefix) => {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries.sort(byName)) {
+      const abs = path.join(dir, entry.name);
+      const name = `${prefix}${entry.name}`;
+      if (entry.isDirectory()) {
+        await walk(abs, `${name}/`);
+        continue;
+      }
+      count += 1;
+      if (count > MAX_BENCHMARK_ARCHIVE_FILES) {
+        throw new BenchmarkUploadError({
+          kind: "tooManyFiles",
+          limit: MAX_BENCHMARK_ARCHIVE_FILES
+        });
+      }
+      if (!entry.isFile()) {
+        const target = entry.isSymbolicLink() ? await fs.readlink(abs).catch(() => "") : "";
+        files[name] = [strToU8(target), { os: UNIX_HOST, attrs: specialMode(entry) << 16 }];
+        continue;
+      }
+      const size = (await fs.stat(abs)).size;
+      if (size > MAX_FILE_BYTES) {
+        throw new BenchmarkUploadError({
+          kind: "fileTooLarge",
+          file: name,
+          limitBytes: MAX_FILE_BYTES
+        });
+      }
+      total += size;
+      if (total > MAX_TOTAL_BYTES) {
+        throw new BenchmarkUploadError({ kind: "tooLarge", limitBytes: MAX_TOTAL_BYTES });
+      }
+      files[name] = new Uint8Array(await fs.readFile(abs));
+    }
+  };
+  await walk(source, "");
+  const zip = zipSync(files);
+  if (zip.byteLength > MAX_ARCHIVE_BYTES) throw zipTooLarge();
+  return zip;
+}
+export {
+  BenchmarkUploadError,
+  readBenchmarkUpload
+};
+//# sourceMappingURL=benchmark-package.js.map

package/dist/benchmark-package.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/benchmark-package.ts"],"sourcesContent":["/**\n * A Benchmark package on this machine as the zip `POST /api/projects/:p/benchmarks/archive` takes:\n * what `penguin benchmark import` uploads. A zip file goes as it is. A folder is zipped whole, its\n * entries at the zip's root and nothing left out — dot-entries, stray files and links included, a\n * link as a link — so that the server's checks (services/benchmark-archive.ts) see what the folder\n * holds and refuse by name what a package may not carry. Nothing is trimmed here: an Agent that\n * imports a folder gets the verdict a person uploading its zip would.\n *\n * The folder is held to the import's caps while it is read — 1000 files, 5MB a file, 20MB in all,\n * 14MB zipped — so a wrong path (a whole repository, say) fails at once rather than being read\n * into memory for the server to refuse.\n *\n * Published as `@prismshadow/penguin-server/benchmark-package`, side-effect-free and without the\n * server, for the CLI.\n */\nimport type { Dirent, Stats } from \"node:fs\";\nimport fs from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { strToU8, zipSync, type Zippable } from \"fflate\";\nimport {\n  MAX_ARCHIVE_BYTES,\n  MAX_BENCHMARK_ARCHIVE_FILES,\n  MAX_FILE_BYTES,\n  MAX_TOTAL_BYTES,\n} from \"./services/skill-import-limits.js\";\n\n/** Why a path cannot go up as a Benchmark package; the caller words it. */\nexport type BenchmarkUploadProblem =\n  | { kind: \"missing\" }\n  /** Neither a folder nor a file. */\n  | { kind: \"unsupported\" }\n  | { kind: \"tooManyFiles\"; limit: number }\n  /** `file` is the entry's path inside the folder. */\n  | { kind: \"fileTooLarge\"; file: string; limitBytes: number }\n  /** The folder's files add up to more than the package may hold. */\n  | { kind: \"tooLarge\"; limitBytes: number }\n  /** The zip, given or made, is larger than an upload may be. */\n  | { kind: \"zipTooLarge\"; limitBytes: number };\n\nexport class BenchmarkUploadError extends Error {\n  constructor(readonly problem: BenchmarkUploadProblem) {\n    super(`Not a Benchmark package upload: ${problem.kind}`);\n    this.name = \"BenchmarkUploadError\";\n  }\n}\n\n/** The zip format's host id for Unix: an entry's high attribute bits are then its `st_mode`. */\nconst UNIX_HOST = 3;\n\n/** The `st_mode` an entry that is neither a file nor a directory is recorded with. */\nfunction specialMode(entry: Dirent): number {\n  if (entry.isSymbolicLink()) return 0o120777;\n  if (entry.isSocket()) return 0o140644;\n  if (entry.isBlockDevice()) return 0o060644;\n  if (entry.isCharacterDevice()) return 0o020644;\n  return 0o010644; // a FIFO, or a type this platform does not name\n}\n\n/** Code-unit order: the same zip from the same folder, whatever the locale. */\nfunction byName(a: Dirent, b: Dirent): number {\n  return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;\n}\n\n/**\n * The bytes to upload for `source`: the zip file itself, or the folder zipped as the module doc\n * says. Throws BenchmarkUploadError for a path that cannot go up (nothing there, past a cap), and\n * whatever the filesystem throws for a path it cannot read.\n */\nexport async function readBenchmarkUpload(source: string): Promise<Uint8Array> {\n  let stat: Stats;\n  try {\n    stat = await fs.stat(source);\n  } catch (error) {\n    if ((error as NodeJS.ErrnoException).code === \"ENOENT\") {\n      throw new BenchmarkUploadError({ kind: \"missing\" });\n    }\n    throw error;\n  }\n  const zipTooLarge = () =>\n    new BenchmarkUploadError({ kind: \"zipTooLarge\", limitBytes: MAX_ARCHIVE_BYTES });\n  if (stat.isFile()) {\n    if (stat.size > MAX_ARCHIVE_BYTES) throw zipTooLarge();\n    return new Uint8Array(await fs.readFile(source));\n  }\n  if (!stat.isDirectory()) throw new BenchmarkUploadError({ kind: \"unsupported\" });\n\n  const files: Zippable = {};\n  let count = 0;\n  let total = 0;\n  const walk = async (dir: string, prefix: string): Promise<void> => {\n    const entries = await fs.readdir(dir, { withFileTypes: true });\n    for (const entry of entries.sort(byName)) {\n      const abs = path.join(dir, entry.name);\n      const name = `${prefix}${entry.name}`;\n      if (entry.isDirectory()) {\n        await walk(abs, `${name}/`);\n        continue;\n      }\n      count += 1;\n      if (count > MAX_BENCHMARK_ARCHIVE_FILES) {\n        throw new BenchmarkUploadError({\n          kind: \"tooManyFiles\",\n          limit: MAX_BENCHMARK_ARCHIVE_FILES,\n        });\n      }\n      if (!entry.isFile()) {\n        // A link or a special file goes in as what it is, its type in the entry's mode and a\n        // link's target as its content, for the server to refuse by name: never followed, never\n        // read.\n        const target = entry.isSymbolicLink() ? await fs.readlink(abs).catch(() => \"\") : \"\";\n        files[name] = [strToU8(target), { os: UNIX_HOST, attrs: specialMode(entry) << 16 }];\n        continue;\n      }\n      const size = (await fs.stat(abs)).size;\n      if (size > MAX_FILE_BYTES) {\n        throw new BenchmarkUploadError({\n          kind: \"fileTooLarge\",\n          file: name,\n          limitBytes: MAX_FILE_BYTES,\n        });\n      }\n      total += size;\n      if (total > MAX_TOTAL_BYTES) {\n        throw new BenchmarkUploadError({ kind: \"tooLarge\", limitBytes: MAX_TOTAL_BYTES });\n      }\n      files[name] = new Uint8Array(await fs.readFile(abs));\n    }\n  };\n  await walk(source, \"\");\n  const zip = zipSync(files);\n  if (zip.byteLength > MAX_ARCHIVE_BYTES) throw zipTooLarge();\n  return zip;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-54E64LWB.js

@@ -0,0 +1,63 @@
+import {
+  HttpError,
+  badRequest
+} from "./chunk-Q4ON2L6E.js";
+
+// src/services/skill-import-limits.ts
+import { unzipSync } from "fflate";
+var MAX_ARCHIVE_BYTES = 14 * 1024 * 1024;
+var MAX_ARCHIVE_FILES = 200;
+var MAX_FILE_BYTES = 5 * 1024 * 1024;
+var MAX_TOTAL_BYTES = 20 * 1024 * 1024;
+var MAX_BENCHMARK_ARCHIVE_FILES = 1e3;
+function assertSafeEntryPath(name) {
+  if (name.includes("\\")) throw badRequest(`Invalid zip entry path (backslash): ${name}`);
+  if (name.startsWith("/") || /^[A-Za-z]:/.test(name)) {
+    throw badRequest(`Invalid zip entry path (absolute): ${name}`);
+  }
+  if (name.split("/").some((segment) => segment === "..")) {
+    throw badRequest(`Invalid zip entry path (traversal): ${name}`);
+  }
+}
+function unzipBounded(archive, limits = {}) {
+  const maxFiles = limits.maxFiles ?? MAX_ARCHIVE_FILES;
+  const tooLarge = limits.tooLarge ?? badRequest;
+  let files = 0;
+  let declared = 0;
+  return unzipSync(archive, {
+    filter: ({ name, originalSize }) => {
+      if (name.endsWith("/")) return true;
+      files += 1;
+      if (files > maxFiles) {
+        throw tooLarge(`The zip archive exceeds the ${maxFiles}-file limit.`);
+      }
+      if (originalSize > MAX_FILE_BYTES) {
+        throw tooLarge(`Zip entry exceeds the 5MB uncompressed limit: ${name}`);
+      }
+      declared += originalSize;
+      if (declared > MAX_TOTAL_BYTES) {
+        throw tooLarge("The zip archive exceeds the 20MB uncompressed limit.");
+      }
+      return true;
+    }
+  });
+}
+function skillTooLarge() {
+  return new HttpError(
+    413,
+    "skill_too_large",
+    `Skill directory exceeds the archive limits (${MAX_ARCHIVE_FILES} files, 5MB per file, 20MB total).`
+  );
+}
+
+export {
+  MAX_ARCHIVE_BYTES,
+  MAX_ARCHIVE_FILES,
+  MAX_FILE_BYTES,
+  MAX_TOTAL_BYTES,
+  MAX_BENCHMARK_ARCHIVE_FILES,
+  assertSafeEntryPath,
+  unzipBounded,
+  skillTooLarge
+};
+//# sourceMappingURL=chunk-54E64LWB.js.map

package/dist/chunk-54E64LWB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/services/skill-import-limits.ts"],"sourcesContent":["/**\n * Caps shared by every path that pulls Skill files in from outside the library — the archive\n * upload/download routes and the directory import. One set of numbers, so a limit raised for one\n * entry point cannot quietly leave another behind, and one message, so the failure reads the same\n * wherever the user hit it. `unzipBounded` is where they are enforced on the way in, since an\n * archive can only be bounded before it is inflated. The Benchmark package archive\n * (benchmark-archive.ts) shares them all but the file count.\n *\n * The CLI loads this module too, through benchmark-package.ts, to hold a folder it uploads to the\n * same caps: it imports fflate and errors.ts and nothing heavier, and keeps it that way.\n */\nimport { unzipSync } from \"fflate\";\nimport { HttpError, badRequest } from \"../http/errors.js\";\n\n/** Decoded zip cap: aligned with the Agent snapshot import (stays within the 20MB body limit after base64). Shared with the hooks and Benchmark archive routes. */\nexport const MAX_ARCHIVE_BYTES = 14 * 1024 * 1024;\nexport const MAX_ARCHIVE_FILES = 200;\nexport const MAX_FILE_BYTES = 5 * 1024 * 1024;\nexport const MAX_TOTAL_BYTES = 20 * 1024 * 1024;\n\n/**\n * A Benchmark package's file cap. Each case carries its statement's and its rubric's materials,\n * so a package of ten cases outgrows the Skill cap long before it nears the byte caps, which it\n * shares.\n */\nexport const MAX_BENCHMARK_ARCHIVE_FILES = 1000;\n\n/**\n * Validates one zip entry path (zip-slip guard): rejects absolute paths (leading \"/\" or a\n * drive letter), backslashes and any \"..\" segment — a malicious archive must never write\n * outside the target directory. Shared by the Skill, hook and Benchmark archive imports.\n */\nexport function assertSafeEntryPath(name: string): void {\n  if (name.includes(\"\\\\\")) throw badRequest(`Invalid zip entry path (backslash): ${name}`);\n  if (name.startsWith(\"/\") || /^[A-Za-z]:/.test(name)) {\n    throw badRequest(`Invalid zip entry path (absolute): ${name}`);\n  }\n  if (name.split(\"/\").some((segment) => segment === \"..\")) {\n    throw badRequest(`Invalid zip entry path (traversal): ${name}`);\n  }\n}\n\n/** What a caller may change about `unzipBounded`'s caps. */\nexport interface UnzipLimits {\n  /** Files the archive may hold; MAX_ARCHIVE_FILES when absent. */\n  maxFiles?: number;\n  /** The error a broken cap throws, given its message; a 400 when absent. */\n  tooLarge?: (message: string) => HttpError;\n}\n\n/**\n * `unzipSync` with the caps above enforced from the central directory, before a byte is inflated.\n *\n * They have to be read there, because `unzipSync` allocates a buffer of each entry's declared\n * uncompressed size and inflates into it — so caps measured on what comes back bound nothing.\n * Zeros deflate at roughly 1000:1, which turns the largest archive the route accepts into\n * gigabytes of allocation; and an entry whose header overstates its size hands back a short view\n * onto a buffer of the declared length, passing every after-the-fact byte check outright.\n *\n * Bounding against the declared sizes is sound in the other direction too: the buffer is exactly\n * the declared size and fflate never grows it, so an entry can only ever yield fewer bytes than\n * it claimed. Directory entries carry no content and are left to the caller to filter.\n *\n * Throws the caps as 400s unless `limits.tooLarge` says otherwise, matching the archive route this\n * was factored out of; a corrupt archive still throws whatever fflate throws, for the caller to\n * translate.\n */\nexport function unzipBounded(\n  archive: Uint8Array,\n  limits: UnzipLimits = {},\n): Record<string, Uint8Array> {\n  const maxFiles = limits.maxFiles ?? MAX_ARCHIVE_FILES;\n  const tooLarge = limits.tooLarge ?? badRequest;\n  let files = 0;\n  let declared = 0;\n  return unzipSync(archive, {\n    filter: ({ name, originalSize }) => {\n      if (name.endsWith(\"/\")) return true;\n      files += 1;\n      if (files > maxFiles) {\n        throw tooLarge(`The zip archive exceeds the ${maxFiles}-file limit.`);\n      }\n      if (originalSize > MAX_FILE_BYTES) {\n        throw tooLarge(`Zip entry exceeds the 5MB uncompressed limit: ${name}`);\n      }\n      declared += originalSize;\n      if (declared > MAX_TOTAL_BYTES) {\n        throw tooLarge(\"The zip archive exceeds the 20MB uncompressed limit.\");\n      }\n      return true;\n    },\n  });\n}\n\nexport function skillTooLarge(): HttpError {\n  return new HttpError(\n    413,\n    \"skill_too_large\",\n    `Skill directory exceeds the archive limits (${MAX_ARCHIVE_FILES} files, 5MB per file, 20MB total).`,\n  );\n}\n"],"mappings":";;;;;;AAWA,SAAS,iBAAiB;AAInB,IAAM,oBAAoB,KAAK,OAAO;AACtC,IAAM,oBAAoB;AAC1B,IAAM,iBAAiB,IAAI,OAAO;AAClC,IAAM,kBAAkB,KAAK,OAAO;AAOpC,IAAM,8BAA8B;AAOpC,SAAS,oBAAoB,MAAoB;AACtD,MAAI,KAAK,SAAS,IAAI,EAAG,OAAM,WAAW,uCAAuC,IAAI,EAAE;AACvF,MAAI,KAAK,WAAW,GAAG,KAAK,aAAa,KAAK,IAAI,GAAG;AACnD,UAAM,WAAW,sCAAsC,IAAI,EAAE;AAAA,EAC/D;AACA,MAAI,KAAK,MAAM,GAAG,EAAE,KAAK,CAAC,YAAY,YAAY,IAAI,GAAG;AACvD,UAAM,WAAW,uCAAuC,IAAI,EAAE;AAAA,EAChE;AACF;AA2BO,SAAS,aACd,SACA,SAAsB,CAAC,GACK;AAC5B,QAAM,WAAW,OAAO,YAAY;AACpC,QAAM,WAAW,OAAO,YAAY;AACpC,MAAI,QAAQ;AACZ,MAAI,WAAW;AACf,SAAO,UAAU,SAAS;AAAA,IACxB,QAAQ,CAAC,EAAE,MAAM,aAAa,MAAM;AAClC,UAAI,KAAK,SAAS,GAAG,EAAG,QAAO;AAC/B,eAAS;AACT,UAAI,QAAQ,UAAU;AACpB,cAAM,SAAS,+BAA+B,QAAQ,cAAc;AAAA,MACtE;AACA,UAAI,eAAe,gBAAgB;AACjC,cAAM,SAAS,iDAAiD,IAAI,EAAE;AAAA,MACxE;AACA,kBAAY;AACZ,UAAI,WAAW,iBAAiB;AAC9B,cAAM,SAAS,sDAAsD;AAAA,MACvE;AACA,aAAO;AAAA,IACT;AAAA,EACF,CAAC;AACH;AAEO,SAAS,gBAA2B;AACzC,SAAO,IAAI;AAAA,IACT;AAAA,IACA;AAAA,IACA,+CAA+C,iBAAiB;AAAA,EAClE;AACF;","names":[]}

package/dist/{chunk-3I2XOPJB.js → chunk-5Z4UCHDB.js}

@@ -1,3 +1,6 @@
+import {
+  HttpError
+} from "./chunk-Q4ON2L6E.js";
 import {
   sessionTokenHash
 } from "./chunk-TOOTEEM4.js";
@@ -36,42 +39,50 @@ async function hashPassword(password, cost = SCRYPT_COST) {
     key.toString("base64")
   ].join("$");
 }
-async function verifyPassword(password, stored) {
+async function checkPassword(password, stored) {
   const parts = stored.split("$");
-  if (parts.length !== 6 || parts[0] !== "scrypt") return false;
+  if (parts.length !== 6 || parts[0] !== "scrypt") return "unverifiable";
   const n = Number(parts[1]);
   const r = Number(parts[2]);
   const p = Number(parts[3]);
-  if (!Number.isInteger(n) || !Number.isInteger(r) || !Number.isInteger(p)) return false;
-  let salt;
-  let expected;
-  try {
-    salt = Buffer.from(parts[4], "base64");
-    expected = Buffer.from(parts[5], "base64");
-  } catch {
-    return false;
-  }
-  if (salt.length === 0 || expected.length === 0) return false;
+  if (!Number.isInteger(n) || !Number.isInteger(r) || !Number.isInteger(p)) return "unverifiable";
+  const salt = Buffer.from(parts[4], "base64");
+  const expected = Buffer.from(parts[5], "base64");
+  if (salt.length === 0 || expected.length === 0) return "unverifiable";
   let actual;
   try {
     actual = await scryptAsync(password, salt, expected.length, n, r, p);
   } catch {
-    return false;
+    return "unverifiable";
   }
-  return actual.length === expected.length && timingSafeEqual(actual, expected);
+  return timingSafeEqual(actual, expected) ? "match" : "mismatch";
+}
+async function verifyPassword(password, stored) {
+  return await checkPassword(password, stored) === "match";
+}
+async function verifyAccountPassword(password, stored, dummyHash, check = checkPassword) {
+  const outcome = stored === null ? "unverifiable" : await check(password, stored);
+  if (outcome !== "unverifiable") return outcome === "match";
+  await check(password, await dummyHash());
+  return false;
 }
-var PasswordHasher = class extends Interface() {
+var _PasswordHasher_decorators, _init;
+_PasswordHasher_decorators = [Interface()];
+var PasswordHasher = class {
 };
-var _ScryptHasher_decorators, _init;
+_init = __decoratorStart(null);
+PasswordHasher = __decorateElement(_init, 0, "PasswordHasher", _PasswordHasher_decorators, PasswordHasher);
+__runInitializers(_init, 1, PasswordHasher);
+var _ScryptHasher_decorators, _init2;
 _ScryptHasher_decorators = [Component()];
 var ScryptHasher = class {
   hash(password) {
     return hashPassword(password, SCRYPT_COST);
   }
 };
-_init = __decoratorStart(null);
-ScryptHasher = __decorateElement(_init, 0, "ScryptHasher", _ScryptHasher_decorators, ScryptHasher);
-__runInitializers(_init, 1, ScryptHasher);
+_init2 = __decoratorStart(null);
+ScryptHasher = __decorateElement(_init2, 0, "ScryptHasher", _ScryptHasher_decorators, ScryptHasher);
+__runInitializers(_init2, 1, ScryptHasher);
 
 // src/auth/service.ts
 import { randomBytes as randomBytes3 } from "crypto";
@@ -102,39 +113,6 @@ function tokensEqual(a, b) {
   return timingSafeEqual2(digest(a), digest(b));
 }
 
-// src/http/errors.ts
-var HttpError = class extends Error {
-  constructor(status, code, message) {
-    super(message);
-    this.status = status;
-    this.code = code;
-    this.name = "HttpError";
-  }
-  status;
-  code;
-};
-function errorBody(code, message) {
-  return { error: { code, message } };
-}
-function isMissingCredential(err) {
-  const message = err instanceof Error ? err.message : String(err);
-  return /missing credentials|api[_ ]?key/i.test(message);
-}
-function modelCredentialMissing(modelId) {
-  return new HttpError(
-    400,
-    "model_credential_missing",
-    `Model ${modelId} has no API key yet. Configure it on the Models page first.`
-  );
-}
-function handleError(err, c) {
-  if (err instanceof HttpError) {
-    return c.json(errorBody(err.code, err.message), err.status);
-  }
-  console.error(`[server] Unhandled exception: ${err.stack ?? err.message}`);
-  return c.json(errorBody("internal", "Internal server error."), 500);
-}
-
 // src/auth/service.ts
 import { Component as Component2, Use, Interface as Interface2 } from "@prismshadow/penguin-core/kernel";
 var MIN_PASSWORD_LENGTH = 8;
@@ -157,19 +135,21 @@ function toUserInfo(row) {
     createdAt: row.createdAt
   };
 }
-var _hasher_dec, _clock_dec, _config_dec, _provisioner_dec, _state_dec, _authSessions_dec, _users_dec, _AuthService_decorators, _init2;
+var _hasher_dec, _clock_dec, _config_dec, _provisioner_dec, _state_dec, _authSessions_dec, _users_dec, _AuthService_decorators, _init3;
 _AuthService_decorators = [Component2()], _users_dec = [Use()], _authSessions_dec = [Use()], _state_dec = [Use()], _provisioner_dec = [Use()], _config_dec = [Use()], _clock_dec = [Use()], _hasher_dec = [Use()];
 var AuthService = class {
   constructor() {
-    __publicField(this, "users", __runInitializers(_init2, 8, this)), __runInitializers(_init2, 11, this);
-    __publicField(this, "authSessions", __runInitializers(_init2, 12, this)), __runInitializers(_init2, 15, this);
-    __publicField(this, "state", __runInitializers(_init2, 16, this)), __runInitializers(_init2, 19, this);
-    __publicField(this, "provisioner", __runInitializers(_init2, 20, this)), __runInitializers(_init2, 23, this);
-    __publicField(this, "config", __runInitializers(_init2, 24, this)), __runInitializers(_init2, 27, this);
-    __publicField(this, "clock", __runInitializers(_init2, 28, this)), __runInitializers(_init2, 31, this);
-    __publicField(this, "hasher", __runInitializers(_init2, 32, this)), __runInitializers(_init2, 35, this);
+    __publicField(this, "users", __runInitializers(_init3, 8, this)), __runInitializers(_init3, 11, this);
+    __publicField(this, "authSessions", __runInitializers(_init3, 12, this)), __runInitializers(_init3, 15, this);
+    __publicField(this, "state", __runInitializers(_init3, 16, this)), __runInitializers(_init3, 19, this);
+    __publicField(this, "provisioner", __runInitializers(_init3, 20, this)), __runInitializers(_init3, 23, this);
+    __publicField(this, "config", __runInitializers(_init3, 24, this)), __runInitializers(_init3, 27, this);
+    __publicField(this, "clock", __runInitializers(_init3, 28, this)), __runInitializers(_init3, 31, this);
+    __publicField(this, "hasher", __runInitializers(_init3, 32, this)), __runInitializers(_init3, 35, this);
     /** Consecutive login failures per userId (see the throttling comment on the constants). */
     __publicField(this, "loginFailures", /* @__PURE__ */ new Map());
+    /** Cache for loginDummyHash. */
+    __publicField(this, "dummyHash", null);
   }
   /** Session lifetime, for the cookie that must expire WITH the session, not before it. */
   get sessionTtlMs() {
@@ -251,6 +231,16 @@ var AuthService = class {
   adminPasswordIsInitial() {
     return this.users.findById(ADMIN_USER_ID)?.passwordIsInitial === true;
   }
+  /**
+   * The hash a sign-in with no account to check is verified against (verifyAccountPassword), so
+   * it costs what a wrong password costs. Made by this server's own hasher, hence at the cost its
+   * real hashes carry, from a random password nobody holds; computed on the first such sign-in
+   * and kept.
+   */
+  async loginDummyHash() {
+    this.dummyHash ??= await this.hasher.hash(randomBytes3(18).toString("base64url"));
+    return this.dummyHash;
+  }
   /** The wait imposed after `failures` consecutive failures (0 while within the free attempts). */
   loginDelayMs(failures) {
     const excess = failures - LOGIN_FREE_ATTEMPTS;
@@ -274,7 +264,11 @@ var AuthService = class {
       }
     }
     const row = this.users.findById(userId);
-    const ok = row !== null && await verifyPassword(password, row.passwordHash);
+    const ok = await verifyAccountPassword(
+      password,
+      row?.passwordHash ?? null,
+      () => this.loginDummyHash()
+    );
     if (!row || !ok) {
       this.loginFailures.set(userId, {
         failures: (failed?.failures ?? 0) + 1,
@@ -286,6 +280,16 @@ var AuthService = class {
     this.authSessions.deleteExpired(this.clock.now().toISOString());
     return { user: toUserInfo(row), token: this.issueSession(row.userId, "password") };
   }
+  /**
+   * Whether a user is an admin, by id — for a caller that has a user's NAME rather than an
+   * authenticated request: the terminal relay reads the owner out of a pty reference the
+   * runtime has already matched against the signed-in user (machines/terminal-relay.ts), and
+   * what is left to decide is whether that user may reach machines at all. Unknown users are
+   * not admins.
+   */
+  isAdmin(userId) {
+    return this.users.findById(userId)?.isAdmin === true;
+  }
   /**
    * Desktop-mode sign-in: an admin session with no password check — the claim route already
    * redeemed the shell's one-shot token, which is the credential here. Throws only on a
@@ -378,6 +382,19 @@ var AuthService = class {
     const via = session.via === "desktop" ? "desktop" : session.via === "setup" ? "setup" : "password";
     return { user, via, renewed };
   }
+  /**
+   * Whether the session behind a cookie token still exists and has not expired — the same
+   * two facts {@link authenticateWithMeta} establishes, without its sliding renewal or its
+   * user lookup. A connection that outlives the request that opened it has to re-ask
+   * periodically (the SSE heartbeat does, once per beat), and asking through the renewing
+   * path would top the expiry up every time: a window nobody has touched since last week
+   * would stay signed in purely because it is still connected.
+   */
+  sessionIsLive(token) {
+    const session = this.authSessions.findByTokenHash(sessionTokenHash(token));
+    if (!session) return false;
+    return Date.parse(session.expiresAt) > this.clock.now().getTime();
+  }
   issueSession(userId, via) {
     return this.authSessions.issue({
       userId,
@@ -387,25 +404,25 @@ var AuthService = class {
     }).token;
   }
 };
-_init2 = __decoratorStart(null);
-__decorateElement(_init2, 5, "users", _users_dec, AuthService);
-__decorateElement(_init2, 5, "authSessions", _authSessions_dec, AuthService);
-__decorateElement(_init2, 5, "state", _state_dec, AuthService);
-__decorateElement(_init2, 5, "provisioner", _provisioner_dec, AuthService);
-__decorateElement(_init2, 5, "config", _config_dec, AuthService);
-__decorateElement(_init2, 5, "clock", _clock_dec, AuthService);
-__decorateElement(_init2, 5, "hasher", _hasher_dec, AuthService);
-AuthService = __decorateElement(_init2, 0, "AuthService", _AuthService_decorators, AuthService);
-__runInitializers(_init2, 1, AuthService);
-var InitialProjectProvisioner = class extends Interface2() {
+_init3 = __decoratorStart(null);
+__decorateElement(_init3, 5, "users", _users_dec, AuthService);
+__decorateElement(_init3, 5, "authSessions", _authSessions_dec, AuthService);
+__decorateElement(_init3, 5, "state", _state_dec, AuthService);
+__decorateElement(_init3, 5, "provisioner", _provisioner_dec, AuthService);
+__decorateElement(_init3, 5, "config", _config_dec, AuthService);
+__decorateElement(_init3, 5, "clock", _clock_dec, AuthService);
+__decorateElement(_init3, 5, "hasher", _hasher_dec, AuthService);
+AuthService = __decorateElement(_init3, 0, "AuthService", _AuthService_decorators, AuthService);
+__runInitializers(_init3, 1, AuthService);
+var _InitialProjectProvisioner_decorators, _init4;
+_InitialProjectProvisioner_decorators = [Interface2()];
+var InitialProjectProvisioner = class {
 };
+_init4 = __decoratorStart(null);
+InitialProjectProvisioner = __decorateElement(_init4, 0, "InitialProjectProvisioner", _InitialProjectProvisioner_decorators, InitialProjectProvisioner);
+__runInitializers(_init4, 1, InitialProjectProvisioner);
 
 export {
-  HttpError,
-  errorBody,
-  isMissingCredential,
-  modelCredentialMissing,
-  handleError,
   mintApiToken,
   storeApiToken,
   hashPassword,
@@ -418,4 +435,4 @@ export {
   AuthService,
   InitialProjectProvisioner
 };
-//# sourceMappingURL=chunk-3I2XOPJB.js.map
+//# sourceMappingURL=chunk-5Z4UCHDB.js.map