@b9g/shovel 0.2.0-beta.2 → 0.2.0-beta.20

package/src/_chunks/chunk-PTLNYIRW.js

@@ -0,0 +1,1158 @@
+// src/utils/project.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+function findProjectRoot(startDir = process.cwd()) {
+  let dir = startDir;
+  while (dir !== dirname(dir)) {
+    if (existsSync(join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = dirname(dir);
+  }
+  return startDir;
+}
+function findWorkspaceRoot(startDir = process.cwd()) {
+  let dir = startDir;
+  while (dir !== dirname(dir)) {
+    const packageJsonPath = join(dir, "package.json");
+    if (existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      if (packageJson.workspaces) {
+        return dir;
+      }
+    }
+    dir = dirname(dir);
+  }
+  return null;
+}
+function getNodeModulesPath(startDir) {
+  return join(findProjectRoot(startDir), "node_modules");
+}
+
+// src/utils/config.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+import { z } from "zod";
+var DEFAULTS = {
+  SERVER: {
+    PORT: 3e3,
+    HOST: "localhost"
+  },
+  WORKERS: 1
+  // Single worker for development - user can override with --workers flag
+};
+var EXPRESSION_PATTERN = /(\|\||\?\?|&&|===|!==|==|!=|\$[A-Za-z_]|\[outdir\]|\[tmpdir\]|\[git\])/;
+function getEnv() {
+  if (typeof import.meta !== "undefined" && import.meta.env) {
+    return import.meta.env;
+  }
+  if (typeof process !== "undefined" && process.env) {
+    return process.env;
+  }
+  return {};
+}
+var Tokenizer = class {
+  #input;
+  #pos;
+  constructor(input) {
+    this.#input = input;
+    this.#pos = 0;
+  }
+  #peek() {
+    return this.#input[this.#pos] || "";
+  }
+  #advance() {
+    return this.#input[this.#pos++] || "";
+  }
+  #skipWhitespace() {
+    while (/\s/.test(this.#peek())) {
+      this.#advance();
+    }
+  }
+  /**
+   * Check if an operator at the current position has required whitespace.
+   * Infix operators must have whitespace on both sides.
+   * Returns true if the operator should be tokenized, false if it should be
+   * treated as part of an identifier.
+   */
+  #hasInfixWhitespace(operatorLength) {
+    const charBefore = this.#pos > 0 ? this.#input[this.#pos - 1] : " ";
+    const charAfter = this.#input[this.#pos + operatorLength] || " ";
+    return /\s/.test(charBefore) && /\s/.test(charAfter);
+  }
+  next() {
+    this.#skipWhitespace();
+    const start = this.#pos;
+    const ch = this.#peek();
+    if (!ch) {
+      return { type: "EOF" /* EOF */, value: null, start, end: start };
+    }
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      this.#advance();
+      let value = "";
+      while (this.#peek() && this.#peek() !== quote) {
+        if (this.#peek() === "\\") {
+          this.#advance();
+          const next = this.#advance();
+          if (next === "n")
+            value += "\n";
+          else if (next === "t")
+            value += "	";
+          else
+            value += next;
+        } else {
+          value += this.#advance();
+        }
+      }
+      if (this.#peek() !== quote) {
+        throw new Error(`Unterminated string at position ${start}`);
+      }
+      this.#advance();
+      return { type: "STRING" /* STRING */, value, start, end: this.#pos };
+    }
+    if (/\d/.test(ch)) {
+      let value = "";
+      while (/\d/.test(this.#peek())) {
+        value += this.#advance();
+      }
+      return {
+        type: "NUMBER" /* NUMBER */,
+        value: parseInt(value, 10),
+        start,
+        end: this.#pos
+      };
+    }
+    if (ch === "=" && this.#input[this.#pos + 1] === "=" && this.#input[this.#pos + 2] === "=" && this.#hasInfixWhitespace(3)) {
+      this.#pos += 3;
+      return { type: "===" /* EQ_STRICT */, value: "===", start, end: this.#pos };
+    }
+    if (ch === "!" && this.#input[this.#pos + 1] === "=" && this.#input[this.#pos + 2] === "=" && this.#hasInfixWhitespace(3)) {
+      this.#pos += 3;
+      return { type: "!==" /* NE_STRICT */, value: "!==", start, end: this.#pos };
+    }
+    if (ch === "=" && this.#input[this.#pos + 1] === "=" && this.#hasInfixWhitespace(2)) {
+      this.#pos += 2;
+      return { type: "==" /* EQ */, value: "==", start, end: this.#pos };
+    }
+    if (ch === "!" && this.#input[this.#pos + 1] === "=" && this.#hasInfixWhitespace(2)) {
+      this.#pos += 2;
+      return { type: "!=" /* NE */, value: "!=", start, end: this.#pos };
+    }
+    if (ch === "|" && this.#input[this.#pos + 1] === "|" && this.#hasInfixWhitespace(2)) {
+      this.#pos += 2;
+      return { type: "||" /* OR */, value: "||", start, end: this.#pos };
+    }
+    if (ch === "&" && this.#input[this.#pos + 1] === "&" && this.#hasInfixWhitespace(2)) {
+      this.#pos += 2;
+      return { type: "&&" /* AND */, value: "&&", start, end: this.#pos };
+    }
+    if (ch === "?" && this.#input[this.#pos + 1] === "?" && this.#hasInfixWhitespace(2)) {
+      this.#pos += 2;
+      return { type: "??" /* NULLISH */, value: "??", start, end: this.#pos };
+    }
+    if (ch === "?" && this.#hasInfixWhitespace(1)) {
+      this.#advance();
+      return { type: "?" /* QUESTION */, value: "?", start, end: this.#pos };
+    }
+    if (ch === ":" && this.#hasInfixWhitespace(1)) {
+      this.#advance();
+      return { type: ":" /* COLON */, value: ":", start, end: this.#pos };
+    }
+    if (ch === "!") {
+      this.#advance();
+      return { type: "!" /* NOT */, value: "!", start, end: this.#pos };
+    }
+    if (ch === "(") {
+      this.#advance();
+      return { type: "(" /* LPAREN */, value: "(", start, end: this.#pos };
+    }
+    if (ch === ")") {
+      this.#advance();
+      return { type: ")" /* RPAREN */, value: ")", start, end: this.#pos };
+    }
+    if (ch === "$") {
+      this.#advance();
+      let name = "";
+      while (/[A-Za-z0-9_]/.test(this.#peek())) {
+        name += this.#advance();
+      }
+      if (!name) {
+        throw new Error(`Expected env var name after $ at position ${start}`);
+      }
+      return { type: "ENV_VAR" /* ENV_VAR */, value: name, start, end: this.#pos };
+    }
+    if (ch === "/") {
+      this.#advance();
+      return { type: "SLASH" /* SLASH */, value: "/", start, end: this.#pos };
+    }
+    if (ch === "[") {
+      const remaining = this.#input.slice(this.#pos);
+      if (remaining.startsWith("[outdir]")) {
+        this.#pos += 8;
+        return {
+          type: "OUTDIR" /* OUTDIR */,
+          value: "[outdir]",
+          start,
+          end: this.#pos
+        };
+      }
+      if (remaining.startsWith("[tmpdir]")) {
+        this.#pos += 8;
+        return {
+          type: "TMPDIR" /* TMPDIR */,
+          value: "[tmpdir]",
+          start,
+          end: this.#pos
+        };
+      }
+      if (remaining.startsWith("[git]")) {
+        this.#pos += 5;
+        return {
+          type: "GIT" /* GIT */,
+          value: "[git]",
+          start,
+          end: this.#pos
+        };
+      }
+      throw new Error(
+        `Unknown placeholder at position ${start}: ${remaining.slice(0, 10)}`
+      );
+    }
+    if (/\S/.test(ch) && !/[$()/]/.test(ch)) {
+      let value = "";
+      while (this.#peek() && /\S/.test(this.#peek()) && !/[$()]/.test(this.#peek())) {
+        if (this.#peek() === "/") {
+          if (this.#input[this.#pos + 1] === "/") {
+            value += this.#advance();
+            value += this.#advance();
+            continue;
+          }
+          break;
+        }
+        value += this.#advance();
+      }
+      if (value === "true")
+        return { type: "TRUE" /* TRUE */, value: true, start, end: this.#pos };
+      if (value === "false")
+        return { type: "FALSE" /* FALSE */, value: false, start, end: this.#pos };
+      if (value === "null")
+        return { type: "NULL" /* NULL */, value: null, start, end: this.#pos };
+      if (value === "undefined")
+        return {
+          type: "UNDEFINED" /* UNDEFINED */,
+          value: void 0,
+          start,
+          end: this.#pos
+        };
+      return { type: "IDENTIFIER" /* IDENTIFIER */, value, start, end: this.#pos };
+    }
+    throw new Error(`Unexpected character '${ch}' at position ${start}`);
+  }
+};
+var Parser = class _Parser {
+  #tokens;
+  #pos;
+  #env;
+  /**
+   * Parse and evaluate a config expression.
+   */
+  static parse(expr, env = {}) {
+    const parser = new _Parser(expr, env);
+    return parser.#parse();
+  }
+  constructor(input, env) {
+    const tokenizer = new Tokenizer(input);
+    this.#tokens = [];
+    let token;
+    do {
+      token = tokenizer.next();
+      this.#tokens.push(token);
+    } while (token.type !== "EOF" /* EOF */);
+    this.#pos = 0;
+    this.#env = env;
+  }
+  #peek() {
+    return this.#tokens[this.#pos];
+  }
+  #advance() {
+    return this.#tokens[this.#pos++];
+  }
+  #expect(type) {
+    const token = this.#peek();
+    if (token.type !== type) {
+      throw new Error(
+        `Expected ${type} but got ${token.type} at position ${token.start}`
+      );
+    }
+    return this.#advance();
+  }
+  #parse() {
+    const result = this.#parseExpr();
+    this.#expect("EOF" /* EOF */);
+    return result;
+  }
+  // Expr := Ternary
+  #parseExpr() {
+    return this.#parseTernary();
+  }
+  // Ternary := LogicalOr ('?' Expr ':' Expr)?
+  #parseTernary() {
+    let left = this.#parseLogicalOr();
+    if (this.#peek().type === "?" /* QUESTION */) {
+      this.#advance();
+      const trueBranch = this.#parseExpr();
+      this.#expect(":" /* COLON */);
+      const falseBranch = this.#parseExpr();
+      return left ? trueBranch : falseBranch;
+    }
+    return left;
+  }
+  // LogicalOr := LogicalAnd (('||' | '??') LogicalAnd)*
+  // ?? and || have same precedence, evaluated left-to-right
+  #parseLogicalOr() {
+    let left = this.#parseLogicalAnd();
+    while (this.#peek().type === "||" /* OR */ || this.#peek().type === "??" /* NULLISH */) {
+      const isNullish = this.#peek().type === "??" /* NULLISH */;
+      this.#advance();
+      const right = this.#parseLogicalAnd();
+      left = isNullish ? left ?? right : left || right;
+    }
+    return left;
+  }
+  // LogicalAnd := Equality ('&&' Equality)*
+  #parseLogicalAnd() {
+    let left = this.#parseEquality();
+    while (this.#peek().type === "&&" /* AND */) {
+      this.#advance();
+      const right = this.#parseEquality();
+      left = left && right;
+    }
+    return left;
+  }
+  // Equality := Unary (('===' | '!==' | '==' | '!=') Unary)*
+  #parseEquality() {
+    let left = this.#parseUnary();
+    while (true) {
+      const token = this.#peek();
+      if (token.type === "===" /* EQ_STRICT */) {
+        this.#advance();
+        const right = this.#parseUnary();
+        left = left === right;
+      } else if (token.type === "!==" /* NE_STRICT */) {
+        this.#advance();
+        const right = this.#parseUnary();
+        left = left !== right;
+      } else if (token.type === "==" /* EQ */) {
+        this.#advance();
+        const right = this.#parseUnary();
+        left = left == right;
+      } else if (token.type === "!=" /* NE */) {
+        this.#advance();
+        const right = this.#parseUnary();
+        left = left != right;
+      } else {
+        break;
+      }
+    }
+    return left;
+  }
+  // Unary := '!' Unary | Primary
+  #parseUnary() {
+    if (this.#peek().type === "!" /* NOT */) {
+      this.#advance();
+      return !this.#parseUnary();
+    }
+    return this.#parsePrimary();
+  }
+  // Primary := PathExpr | Literal | '(' Expr ')'
+  // PathExpr := (EnvVar | Dunder | Identifier) PathSuffix?
+  // PathSuffix := ('/' Segment)+
+  #parsePrimary() {
+    const token = this.#peek();
+    if (token.type === "(" /* LPAREN */) {
+      this.#advance();
+      const value = this.#parseExpr();
+      this.#expect(")" /* RPAREN */);
+      return this.#parsePathSuffix(value);
+    }
+    if (token.type === "STRING" /* STRING */) {
+      this.#advance();
+      return token.value;
+    }
+    if (token.type === "NUMBER" /* NUMBER */) {
+      this.#advance();
+      return token.value;
+    }
+    if (token.type === "TRUE" /* TRUE */) {
+      this.#advance();
+      return true;
+    }
+    if (token.type === "FALSE" /* FALSE */) {
+      this.#advance();
+      return false;
+    }
+    if (token.type === "NULL" /* NULL */) {
+      this.#advance();
+      return null;
+    }
+    if (token.type === "UNDEFINED" /* UNDEFINED */) {
+      this.#advance();
+      return void 0;
+    }
+    if (token.type === "ENV_VAR" /* ENV_VAR */) {
+      this.#advance();
+      const name = token.value;
+      const value = this.#env[name];
+      let result = value;
+      if (typeof value === "string" && /^\d+$/.test(value)) {
+        result = parseInt(value, 10);
+      }
+      return this.#parsePathSuffix(result);
+    }
+    if (token.type === "OUTDIR" /* OUTDIR */ || token.type === "TMPDIR" /* TMPDIR */ || token.type === "GIT" /* GIT */) {
+      throw new Error(
+        `${token.value} placeholder is only valid in build config, not runtime`
+      );
+    }
+    if (token.type === "IDENTIFIER" /* IDENTIFIER */) {
+      this.#advance();
+      return this.#parsePathSuffix(token.value);
+    }
+    throw new Error(
+      `Unexpected token ${token.type} at position ${token.start}`
+    );
+  }
+  // Parse optional path suffix: ('/' Segment)+
+  // Returns the value joined with any path segments
+  #parsePathSuffix(base) {
+    const segments = [];
+    while (this.#peek().type === "SLASH" /* SLASH */) {
+      this.#advance();
+      const segToken = this.#peek();
+      if (segToken.type === "IDENTIFIER" /* IDENTIFIER */ || segToken.type === "STRING" /* STRING */) {
+        this.#advance();
+        segments.push(segToken.value);
+      } else if (segToken.type === "NUMBER" /* NUMBER */) {
+        this.#advance();
+        segments.push(String(segToken.value));
+      } else {
+        throw new Error(
+          `Expected path segment after / at position ${segToken.start}`
+        );
+      }
+    }
+    if (segments.length === 0) {
+      return base;
+    }
+    if (base === void 0) {
+      return void 0;
+    }
+    return join2(String(base), ...segments);
+  }
+};
+function processConfigValue(value, env) {
+  if (typeof value === "string") {
+    if (EXPRESSION_PATTERN.test(value)) {
+      const result = Parser.parse(value, env);
+      if (result === void 0) {
+        throw new Error(
+          `Config expression "${value}" evaluated to undefined.
+Add a fallback: ${value} || defaultValue`
+        );
+      }
+      return result;
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => processConfigValue(item, env));
+  }
+  if (value !== null && typeof value === "object") {
+    const processed = {};
+    for (const [key, val] of Object.entries(value)) {
+      processed[key] = processConfigValue(val, env);
+    }
+    return processed;
+  }
+  return value;
+}
+var CodeGenerator = class {
+  #tokens;
+  #pos;
+  constructor(input) {
+    const tokenizer = new Tokenizer(input);
+    this.#tokens = [];
+    let token;
+    do {
+      token = tokenizer.next();
+      this.#tokens.push(token);
+    } while (token.type !== "EOF" /* EOF */);
+    this.#pos = 0;
+  }
+  #peek() {
+    return this.#tokens[this.#pos];
+  }
+  #advance() {
+    return this.#tokens[this.#pos++];
+  }
+  #expect(type) {
+    const token = this.#peek();
+    if (token.type !== type) {
+      throw new Error(
+        `Expected ${type} but got ${token.type} at position ${token.start}`
+      );
+    }
+    return this.#advance();
+  }
+  generate() {
+    const result = this.#generateExpr();
+    this.#expect("EOF" /* EOF */);
+    return result;
+  }
+  #generateExpr() {
+    return this.#generateTernary();
+  }
+  #generateTernary() {
+    let left = this.#generateLogicalOr();
+    if (this.#peek().type === "?" /* QUESTION */) {
+      this.#advance();
+      const trueBranch = this.#generateExpr();
+      this.#expect(":" /* COLON */);
+      const falseBranch = this.#generateExpr();
+      return `(${left} ? ${trueBranch} : ${falseBranch})`;
+    }
+    return left;
+  }
+  #generateLogicalOr() {
+    let left = this.#generateLogicalAnd();
+    while (this.#peek().type === "||" /* OR */ || this.#peek().type === "??" /* NULLISH */) {
+      const op = this.#peek().type === "??" /* NULLISH */ ? "??" : "||";
+      this.#advance();
+      const right = this.#generateLogicalAnd();
+      left = `(${left} ${op} ${right})`;
+    }
+    return left;
+  }
+  #generateLogicalAnd() {
+    let left = this.#generateEquality();
+    while (this.#peek().type === "&&" /* AND */) {
+      this.#advance();
+      const right = this.#generateEquality();
+      left = `(${left} && ${right})`;
+    }
+    return left;
+  }
+  #generateEquality() {
+    let left = this.#generateUnary();
+    while (true) {
+      const token = this.#peek();
+      if (token.type === "===" /* EQ_STRICT */) {
+        this.#advance();
+        const right = this.#generateUnary();
+        left = `(${left} === ${right})`;
+      } else if (token.type === "!==" /* NE_STRICT */) {
+        this.#advance();
+        const right = this.#generateUnary();
+        left = `(${left} !== ${right})`;
+      } else if (token.type === "==" /* EQ */) {
+        this.#advance();
+        const right = this.#generateUnary();
+        left = `(${left} == ${right})`;
+      } else if (token.type === "!=" /* NE */) {
+        this.#advance();
+        const right = this.#generateUnary();
+        left = `(${left} != ${right})`;
+      } else {
+        break;
+      }
+    }
+    return left;
+  }
+  #generateUnary() {
+    if (this.#peek().type === "!" /* NOT */) {
+      this.#advance();
+      return `!${this.#generateUnary()}`;
+    }
+    return this.#generatePrimary();
+  }
+  #generatePrimary() {
+    const token = this.#peek();
+    if (token.type === "(" /* LPAREN */) {
+      this.#advance();
+      const value = this.#generateExpr();
+      this.#expect(")" /* RPAREN */);
+      return this.#generatePathSuffix(`(${value})`);
+    }
+    if (token.type === "STRING" /* STRING */) {
+      this.#advance();
+      return JSON.stringify(token.value);
+    }
+    if (token.type === "NUMBER" /* NUMBER */) {
+      this.#advance();
+      return String(token.value);
+    }
+    if (token.type === "TRUE" /* TRUE */) {
+      this.#advance();
+      return "true";
+    }
+    if (token.type === "FALSE" /* FALSE */) {
+      this.#advance();
+      return "false";
+    }
+    if (token.type === "NULL" /* NULL */) {
+      this.#advance();
+      return "null";
+    }
+    if (token.type === "UNDEFINED" /* UNDEFINED */) {
+      this.#advance();
+      return "undefined";
+    }
+    if (token.type === "ENV_VAR" /* ENV_VAR */) {
+      this.#advance();
+      const name = token.value;
+      const code = /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name) ? `process.env.${name}` : `process.env[${JSON.stringify(name)}]`;
+      return this.#generatePathSuffix(code, { requiredEnvVar: name });
+    }
+    if (token.type === "OUTDIR" /* OUTDIR */) {
+      this.#advance();
+      return this.#generatePathSuffix("__SHOVEL_OUTDIR__");
+    }
+    if (token.type === "TMPDIR" /* TMPDIR */) {
+      this.#advance();
+      return this.#generatePathSuffix("tmpdir()");
+    }
+    if (token.type === "GIT" /* GIT */) {
+      this.#advance();
+      return this.#generatePathSuffix("__SHOVEL_GIT__");
+    }
+    if (token.type === "IDENTIFIER" /* IDENTIFIER */) {
+      this.#advance();
+      return this.#generatePathSuffix(JSON.stringify(token.value));
+    }
+    throw new Error(
+      `Unexpected token ${token.type} at position ${token.start}`
+    );
+  }
+  // Generate path suffix code: base/segment/... → [base, "segment", ...].join("/")
+  // If requiredEnvVar is set, generate code that throws if the env var is missing
+  #generatePathSuffix(baseCode, options = {}) {
+    const segments = [];
+    while (this.#peek().type === "SLASH" /* SLASH */) {
+      this.#advance();
+      const segToken = this.#peek();
+      if (segToken.type === "IDENTIFIER" /* IDENTIFIER */ || segToken.type === "STRING" /* STRING */) {
+        this.#advance();
+        segments.push(JSON.stringify(segToken.value));
+      } else if (segToken.type === "NUMBER" /* NUMBER */) {
+        this.#advance();
+        segments.push(JSON.stringify(String(segToken.value)));
+      } else {
+        throw new Error(
+          `Expected path segment after / at position ${segToken.start}`
+        );
+      }
+    }
+    if (segments.length === 0) {
+      return baseCode;
+    }
+    if (options.requiredEnvVar) {
+      const envName = options.requiredEnvVar;
+      return `(() => { const v = ${baseCode}; if (v == null) throw new Error("Required env var ${envName} is not set"); return [v, ${segments.join(", ")}].join("/"); })()`;
+    }
+    return `[${baseCode}, ${segments.join(", ")}].filter(Boolean).join("/")`;
+  }
+};
+function exprToCode(expr) {
+  if (EXPRESSION_PATTERN.test(expr)) {
+    try {
+      const generator = new CodeGenerator(expr);
+      const code = generator.generate();
+      return { code };
+    } catch (error) {
+      throw new Error(
+        `Invalid config expression: ${expr}
+Error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return { code: JSON.stringify(expr) };
+}
+function sanitizeVarName(pattern) {
+  return pattern.replace(/\*/g, "default").replace(/[^a-zA-Z0-9_]/g, "_").replace(/^(\d)/, "_$1");
+}
+var PLACEHOLDER_PREFIX = "__SHOVEL_";
+function needsQuoting(key) {
+  return !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key);
+}
+function containsRuntimeExpressions(code) {
+  return code.includes("process.env") || code.includes("tmpdir()") || code.includes(".filter(Boolean).join");
+}
+function toJSLiteral(value, placeholders, indent = "") {
+  if (value === null)
+    return { code: "null", isDynamic: false };
+  if (value === void 0)
+    return { code: "undefined", isDynamic: false };
+  if (typeof value === "string") {
+    if (value.startsWith(PLACEHOLDER_PREFIX) && placeholders.has(value)) {
+      return { code: placeholders.get(value), isDynamic: false };
+    }
+    const result = exprToCode(value);
+    return {
+      code: result.code,
+      isDynamic: containsRuntimeExpressions(result.code)
+    };
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return { code: String(value), isDynamic: false };
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0)
+      return { code: "[]", isDynamic: false };
+    let anyDynamic = false;
+    const items = value.map((v) => {
+      const result = toJSLiteral(v, placeholders, indent + "  ");
+      if (result.isDynamic)
+        anyDynamic = true;
+      return result.code;
+    });
+    return {
+      code: `[
+${indent}  ${items.join(`,
+${indent}  `)}
+${indent}]`,
+      isDynamic: anyDynamic
+    };
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0)
+      return { code: "{}", isDynamic: false };
+    let anyDynamic = false;
+    const props = entries.map(([k, v]) => {
+      const keyStr = needsQuoting(k) ? JSON.stringify(k) : k;
+      const result = toJSLiteral(v, placeholders, indent + "  ");
+      if (result.isDynamic)
+        anyDynamic = true;
+      if (result.isDynamic) {
+        return `get ${keyStr}() { return ${result.code}; }`;
+      }
+      return `${keyStr}: ${result.code}`;
+    });
+    return {
+      code: `{
+${indent}  ${props.join(`,
+${indent}  `)}
+${indent}}`,
+      isDynamic: anyDynamic
+    };
+  }
+  return { code: JSON.stringify(value), isDynamic: false };
+}
+function generateConfigModule(rawConfig, options) {
+  const { platformDefaults = {}, lifecycle } = options;
+  const imports = [];
+  const placeholders = /* @__PURE__ */ new Map();
+  let placeholderCounter = 0;
+  function createPlaceholder(jsCode) {
+    const placeholder = `${PLACEHOLDER_PREFIX}${placeholderCounter++}__`;
+    placeholders.set(placeholder, jsCode);
+    return placeholder;
+  }
+  const addedImports = /* @__PURE__ */ new Map();
+  function processModule(modulePath, exportName, type, name) {
+    if (!modulePath)
+      return null;
+    const varName = `${type}_${sanitizeVarName(name)}`;
+    const actualExport = exportName || "default";
+    const importKey = `${modulePath}:${actualExport}`;
+    const existingVarName = addedImports.get(importKey);
+    if (existingVarName) {
+      return createPlaceholder(existingVarName);
+    }
+    addedImports.set(importKey, varName);
+    if (actualExport === "default") {
+      imports.push(`import ${varName} from ${JSON.stringify(modulePath)};`);
+    } else {
+      imports.push(
+        `import { ${actualExport} as ${varName} } from ${JSON.stringify(modulePath)};`
+      );
+    }
+    return createPlaceholder(varName);
+  }
+  function reifyModule(config2, type, name) {
+    const { module: modulePath, export: exportName, ...rest } = config2;
+    const implPlaceholder = processModule(modulePath, exportName, type, name);
+    if (implPlaceholder) {
+      return { ...rest, impl: implPlaceholder };
+    }
+    return rest;
+  }
+  function processSink(sink, sinkName) {
+    return reifyModule(sink, "sink", sinkName);
+  }
+  function buildConfig() {
+    const config2 = {};
+    if (rawConfig.platform !== void 0) {
+      config2.platform = rawConfig.platform;
+    }
+    if (rawConfig.port !== void 0) {
+      config2.port = rawConfig.port;
+    } else {
+      config2.port = createPlaceholder(
+        "process.env.PORT ? parseInt(process.env.PORT, 10) : 3000"
+      );
+    }
+    if (rawConfig.host !== void 0) {
+      config2.host = rawConfig.host;
+    } else {
+      config2.host = createPlaceholder('process.env.HOST || "localhost"');
+    }
+    if (rawConfig.workers !== void 0) {
+      config2.workers = rawConfig.workers;
+    } else {
+      config2.workers = createPlaceholder(
+        "process.env.WORKERS ? parseInt(process.env.WORKERS, 10) : 1"
+      );
+    }
+    const logging = {};
+    const sinks = {};
+    if (rawConfig.logging?.sinks) {
+      for (const [name, sinkConfig] of Object.entries(
+        rawConfig.logging.sinks
+      )) {
+        sinks[name] = processSink(sinkConfig, name);
+      }
+    }
+    logging.sinks = sinks;
+    const loggers = [];
+    if (rawConfig.logging?.loggers) {
+      for (const loggerConfig of rawConfig.logging.loggers) {
+        const logger = {
+          category: loggerConfig.category
+        };
+        if (loggerConfig.level) {
+          logger.level = loggerConfig.level;
+        }
+        if (loggerConfig.sinks) {
+          logger.sinks = loggerConfig.sinks;
+        }
+        if (loggerConfig.parentSinks) {
+          logger.parentSinks = loggerConfig.parentSinks;
+        }
+        loggers.push(logger);
+      }
+    }
+    logging.loggers = loggers;
+    config2.logging = logging;
+    const platformCaches = platformDefaults.caches || {};
+    const userCaches = rawConfig.caches || {};
+    const allCacheNames = /* @__PURE__ */ new Set([
+      ...Object.keys(platformCaches),
+      ...Object.keys(userCaches)
+    ]);
+    if (allCacheNames.size > 0) {
+      const caches = {};
+      for (const name of allCacheNames) {
+        const platformConfig = platformCaches[name] || {};
+        const userConfig = userCaches[name] || {};
+        const mergedConfig = { ...platformConfig, ...userConfig };
+        caches[name] = reifyModule(mergedConfig, "cache", name);
+      }
+      config2.caches = caches;
+    }
+    const platformDirectories = platformDefaults.directories || {};
+    const userDirectories = rawConfig.directories || {};
+    const allDirectoryNames = /* @__PURE__ */ new Set([
+      ...Object.keys(platformDirectories),
+      ...Object.keys(userDirectories)
+    ]);
+    if (allDirectoryNames.size > 0) {
+      const directories = {};
+      for (const name of allDirectoryNames) {
+        const platformConfig = platformDirectories[name] || {};
+        const userConfig = userDirectories[name] || {};
+        const mergedConfig = { ...platformConfig, ...userConfig };
+        directories[name] = reifyModule(mergedConfig, "directory", name);
+      }
+      config2.directories = directories;
+    }
+    if (rawConfig.databases && Object.keys(rawConfig.databases).length > 0) {
+      const databases = {};
+      for (const [name, dbConfig] of Object.entries(rawConfig.databases)) {
+        databases[name] = reifyModule(dbConfig, "database", name);
+      }
+      config2.databases = databases;
+    }
+    if (lifecycle) {
+      config2.lifecycle = {
+        stage: lifecycle.stage
+      };
+    }
+    return config2;
+  }
+  const config = buildConfig();
+  const { code: configCode } = toJSLiteral(config, placeholders, "");
+  const needsTmpdirImport = configCode.includes("tmpdir()");
+  if (needsTmpdirImport) {
+    imports.unshift('import {tmpdir} from "os";');
+  }
+  const providerImports = imports.length > 0 ? `${imports.join("\n")}
+` : "";
+  return `${providerImports}
+export const config = ${configCode};
+`;
+}
+function loadRawConfig(cwd) {
+  let rawConfig = {};
+  let configSource = "defaults";
+  try {
+    const shovelPath = `${cwd}/shovel.json`;
+    const content = readFileSync2(shovelPath, "utf-8");
+    rawConfig = JSON.parse(content);
+    configSource = "shovel.json";
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw error;
+    }
+    try {
+      const pkgPath = `${cwd}/package.json`;
+      const content = readFileSync2(pkgPath, "utf-8");
+      const pkgJSON = JSON.parse(content);
+      if (pkgJSON.shovel) {
+        rawConfig = pkgJSON.shovel;
+        configSource = "package.json";
+      }
+    } catch (error2) {
+      if (error2?.code !== "ENOENT") {
+        throw error2;
+      }
+    }
+  }
+  try {
+    return ShovelConfigSchema.parse(rawConfig);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const issues = error.issues.map((issue) => `  - ${issue.path.join(".")}: ${issue.message}`).join("\n");
+      throw new Error(`Invalid config in ${configSource}:
+${issues}`);
+    }
+    throw error;
+  }
+}
+var configExpr = z.union([z.string(), z.number()]);
+var CacheConfigSchema = z.object({
+  module: z.string().optional(),
+  export: z.string().optional(),
+  url: configExpr.optional(),
+  maxEntries: configExpr.optional(),
+  TTL: configExpr.optional()
+}).strict();
+var DirectoryConfigSchema = z.object({
+  module: z.string().optional(),
+  export: z.string().optional(),
+  path: configExpr.optional(),
+  binding: configExpr.optional(),
+  bucket: configExpr.optional(),
+  region: configExpr.optional(),
+  endpoint: configExpr.optional()
+}).strict();
+var DatabaseConfigSchema = z.object({
+  /** Module path to import (e.g., "@b9g/zen/bun") */
+  module: z.string(),
+  /** Named export to use (defaults to "default") */
+  export: z.string().optional(),
+  /** Database connection URL (can be null for intentional null fallbacks) */
+  url: z.string().nullable()
+}).passthrough();
+var LogLevelSchema = z.enum(["debug", "info", "warning", "error"]);
+var SinkConfigSchema = z.object({
+  module: z.string(),
+  export: z.string().optional()
+}).passthrough();
+var LoggerConfigSchema = z.object({
+  category: z.union([z.string(), z.array(z.string())]),
+  level: LogLevelSchema.optional(),
+  sinks: z.array(z.string()).optional(),
+  parentSinks: z.literal("override").optional()
+}).strict();
+var LoggingConfigSchema = z.object({
+  sinks: z.record(z.string(), SinkConfigSchema).optional(),
+  loggers: z.array(LoggerConfigSchema).optional()
+}).strict();
+var BuildPluginConfigSchema = z.object({
+  /** Module path to import (e.g., "esbuild-plugin-tailwindcss") */
+  module: z.string(),
+  /** Named export to use (defaults to "default") */
+  export: z.string().optional()
+}).passthrough();
+var BuildConfigSchema = z.object({
+  /** ES target (e.g., "es2020", "es2022", ["es2020", "chrome100"]) */
+  target: z.union([z.string(), z.array(z.string())]).optional(),
+  /** Enable minification for production builds */
+  minify: z.boolean().optional(),
+  /** Sourcemap generation: false, true, "inline", "external", "linked" */
+  sourcemap: z.union([z.boolean(), z.enum(["inline", "external", "linked"])]).optional(),
+  /** Enable tree-shaking (default: true) */
+  treeShaking: z.boolean().optional(),
+  /** Global constant definitions (added to Shovel's defaults) */
+  define: z.record(z.string(), z.string()).optional(),
+  /** Path aliases (e.g., {"@": "./src"}) */
+  alias: z.record(z.string(), z.string()).optional(),
+  /** Additional external packages (added to platform defaults) */
+  external: z.array(z.string()).optional(),
+  /** ESBuild plugins using module/export pattern */
+  plugins: z.array(BuildPluginConfigSchema).optional()
+}).strict();
+var ShovelConfigSchema = z.object({
+  platform: z.string().optional(),
+  port: z.union([z.number(), z.string()]).optional(),
+  host: z.string().optional(),
+  workers: z.union([z.number(), z.string()]).optional(),
+  logging: LoggingConfigSchema.optional(),
+  build: BuildConfigSchema.optional(),
+  caches: z.record(z.string(), CacheConfigSchema).optional(),
+  directories: z.record(z.string(), DirectoryConfigSchema).optional(),
+  databases: z.record(z.string(), DatabaseConfigSchema).optional()
+}).strict();
+function loadConfig(cwd) {
+  const env = getEnv();
+  let rawConfig = {};
+  try {
+    const shovelPath = `${cwd}/shovel.json`;
+    const content = readFileSync2(shovelPath, "utf-8");
+    rawConfig = JSON.parse(content);
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw error;
+    }
+    try {
+      const pkgPath = `${cwd}/package.json`;
+      const content = readFileSync2(pkgPath, "utf-8");
+      const pkgJSON = JSON.parse(content);
+      rawConfig = pkgJSON.shovel || {};
+    } catch (error2) {
+      if (error2?.code !== "ENOENT") {
+        throw error2;
+      }
+    }
+  }
+  const processed = processConfigValue(rawConfig, env);
+  const config = {
+    platform: processed.platform ?? env.PLATFORM ?? void 0,
+    port: processed.port !== void 0 ? typeof processed.port === "number" ? processed.port : parseInt(String(processed.port), 10) : env.PORT ? parseInt(env.PORT, 10) : 3e3,
+    host: processed.host ?? env.HOST ?? "localhost",
+    workers: processed.workers !== void 0 ? typeof processed.workers === "number" ? processed.workers : parseInt(String(processed.workers), 10) : env.WORKERS ? parseInt(env.WORKERS, 10) : 1,
+    logging: {
+      sinks: processed.logging?.sinks || {},
+      loggers: processed.logging?.loggers || []
+    },
+    build: {
+      target: processed.build?.target ?? "es2022",
+      minify: processed.build?.minify ?? false,
+      sourcemap: processed.build?.sourcemap ?? false,
+      treeShaking: processed.build?.treeShaking ?? true,
+      define: processed.build?.define ?? {},
+      alias: processed.build?.alias ?? {},
+      external: processed.build?.external ?? [],
+      plugins: processed.build?.plugins ?? []
+    },
+    caches: processed.caches || {},
+    directories: processed.directories || {},
+    databases: processed.databases || {}
+  };
+  return config;
+}
+function generateStorageTypes(config, options = {}) {
+  const { platformDefaults = {} } = options;
+  const mergedDirectories = {
+    ...platformDefaults.directories || {},
+    ...config.directories || {}
+  };
+  const mergedCaches = {
+    ...platformDefaults.caches || {},
+    ...config.caches || {}
+  };
+  const databaseNames = config.databases ? Object.keys(config.databases) : [];
+  const directoryNames = Object.keys(mergedDirectories);
+  const cacheNames = Object.keys(mergedCaches);
+  if (databaseNames.length === 0 && directoryNames.length === 0 && cacheNames.length === 0) {
+    return "";
+  }
+  const imports = [];
+  const sections = [];
+  if (databaseNames.length > 0) {
+    imports.push(`import type {Database} from "@b9g/zen";`);
+    imports.push(`import type {DatabaseUpgradeEvent} from "@b9g/platform";`);
+    const dbUnion = databaseNames.map((n) => `"${n}"`).join(" | ");
+    sections.push(`  /**
+   * Valid database names from shovel.json.
+   * Using an invalid name will cause a TypeScript error.
+   */
+  type ValidDatabaseName = ${dbUnion};
+
+  interface DatabaseStorage {
+    /** Open a database at a specific version, running migrations if needed */
+    open(
+      name: ValidDatabaseName,
+      version: number,
+      onUpgrade?: (event: DatabaseUpgradeEvent) => void,
+    ): Promise<Database>;
+    /** Get an already-opened database (throws if not opened) */
+    get(name: ValidDatabaseName): Database;
+    /** Close a specific database */
+    close(name: ValidDatabaseName): Promise<void>;
+    /** Close all databases */
+    closeAll(): Promise<void>;
+  }`);
+  }
+  if (directoryNames.length > 0) {
+    const dirUnion = directoryNames.map((n) => `"${n}"`).join(" | ");
+    sections.push(`  /**
+   * Valid directory names from shovel.json and platform defaults.
+   * Using an invalid name will cause a TypeScript error.
+   */
+  type ValidDirectoryName = ${dirUnion};
+
+  interface DirectoryStorage {
+    open(name: ValidDirectoryName): Promise<FileSystemDirectoryHandle>;
+    has(name: ValidDirectoryName): Promise<boolean>;
+  }`);
+  }
+  if (cacheNames.length > 0) {
+    const cacheUnion = cacheNames.map((n) => `"${n}"`).join(" | ");
+    sections.push(`  /**
+   * Valid cache names from shovel.json and platform defaults.
+   * Using an invalid name will cause a TypeScript error.
+   */
+  type ValidCacheName = ${cacheUnion};
+
+  interface CacheStorage {
+    open(name: ValidCacheName): Promise<Cache>;
+    has(name: ValidCacheName): Promise<boolean>;
+    delete(name: ValidCacheName): Promise<boolean>;
+    keys(): Promise<string[]>;
+  }`);
+  }
+  return `// Generated by Shovel - DO NOT EDIT
+// This file provides typed overloads for self.databases, self.directories, and self.caches
+${imports.join("\n")}
+
+declare global {
+${sections.join("\n\n")}
+}
+
+export {};
+`;
+}
+
+export {
+  findProjectRoot,
+  findWorkspaceRoot,
+  getNodeModulesPath,
+  DEFAULTS,
+  generateConfigModule,
+  loadRawConfig,
+  loadConfig,
+  generateStorageTypes
+};