@liquidmetal-ai/raindrop 0.13.0 → 0.15.0

package/bundle/chunk-5XHDP4VK.js

@@ -0,0 +1,1697 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// bin/cjs-shims.js
+import { createRequire } from "node:module";
+import path from "node:path";
+import url from "node:url";
+var init_cjs_shims = __esm({
+  "bin/cjs-shims.js"() {
+    "use strict";
+    globalThis.require = createRequire(import.meta.url);
+    globalThis.__filename = url.fileURLToPath(import.meta.url);
+    globalThis.__dirname = path.dirname(__filename);
+  }
+});
+
+// ../drizzle/dist/appify/build.js
+init_cjs_shims();
+
+// ../drizzle/dist/appify/parse.js
+init_cjs_shims();
+var TOKEN_PATTERNS = [
+  { type: "number", pattern: /^\d+(\.\d+)?/ },
+  { type: "comment", pattern: /^(\/\/|#)[^\n]*/ },
+  { type: "operator", pattern: /^[+\-*/%=]/ },
+  { type: "whitespace", pattern: /^[ \t]+/ },
+  { type: "boolean", pattern: /^(true|false)/ },
+  { type: "string", pattern: /^'(?:[^'\\\n]|\\.)*'/ },
+  { type: "string", pattern: /^"(?:[^"\\\n]|\\.)*"/ },
+  { type: "identifier", pattern: /^[a-zA-Z_]\w*/ },
+  { type: "newline", pattern: /^\n/ },
+  { type: "curly", pattern: /^[{}]/ },
+  { type: "comma", pattern: /^,/ },
+  // eslint-disable-next-line no-useless-escape
+  { type: "bracket", pattern: /^[\[\]]/ },
+  { type: "parenthesis", pattern: /^[()]/ },
+  { type: "unknown", pattern: /^./ }
+];
+var Tokenizer = class {
+  input;
+  cursor = 0;
+  line = 1;
+  column = 1;
+  constructor(input) {
+    this.input = input;
+  }
+  // Get the next token from the input. The optional ignore parameter
+  // can be used to skip certain token types. This could possibly be
+  // removed, but whitespace might be useful at some point.
+  next(ignore = ["whitespace"]) {
+    if (this.eof()) {
+      return {
+        type: "end",
+        value: "",
+        start: this.cursor,
+        end: this.cursor,
+        line: this.line,
+        column: this.column
+      };
+    }
+    for (const { type, pattern } of TOKEN_PATTERNS) {
+      const result = this.input.slice(this.cursor).match(pattern);
+      if (result) {
+        const token = {
+          type,
+          value: result[0],
+          start: this.cursor,
+          end: this.cursor + result[0].length,
+          line: this.line,
+          column: this.column
+        };
+        this.cursor += result[0].length;
+        if (type === "newline") {
+          this.line++;
+          this.column = 1;
+        } else {
+          this.column += result[0].length;
+        }
+        if (ignore.includes(token.type)) {
+          return this.next(ignore);
+        }
+        return token;
+      }
+    }
+    throw new Error(`Unknown token at ${this.line}:${this.column}`);
+  }
+  peek(ignore = ["whitespace"]) {
+    const cursor = this.cursor;
+    const line = this.line;
+    const column = this.column;
+    const token = this.next(ignore);
+    this.cursor = cursor;
+    this.line = line;
+    this.column = column;
+    return token;
+  }
+  eof() {
+    return this.cursor >= this.input.length;
+  }
+};
+var Parser = class {
+  tokenizer;
+  errors = [];
+  constructor(tokenizer) {
+    this.tokenizer = tokenizer;
+  }
+  // Parse the input and return the AST. The optional node parameter
+  // is used when this is recursed.
+  parse(root) {
+    if (root === void 0) {
+      root = {
+        type: "block",
+        children: [],
+        line: this.tokenizer.line,
+        column: this.tokenizer.column,
+        start: this.tokenizer.cursor,
+        end: 0
+      };
+    }
+    while (!this.tokenizer.eof()) {
+      const token = this.tokenizer.peek();
+      switch (token.type) {
+        case "identifier":
+          root.children.push(this.parseIdentifier());
+          break;
+        case "newline":
+          root.children.push(this.tokenizer.next());
+          break;
+        case "comment":
+          root.children.push(this.tokenizer.next());
+          break;
+        case "curly":
+          if (token.value === "}") {
+            root.end = this.tokenizer.cursor;
+            return root;
+          } else {
+            this.errors.push({
+              expected: ["identifier"],
+              received: "curly",
+              message: `Unexpected ${token.value} at ${token.line}:${token.column}`,
+              line: token.line,
+              column: token.column,
+              start: token.start,
+              end: token.end
+            });
+            this.tokenizer.next();
+          }
+          break;
+        case "end":
+          root.end = this.tokenizer.cursor;
+          return root;
+        default:
+          this.errors.push({
+            expected: ["identifier", "newline", "comment"],
+            received: token.type,
+            message: `Unexpected ${token.type} at ${token.line}:${token.column}`,
+            line: token.line,
+            column: token.column,
+            start: token.start,
+            end: token.end
+          });
+          root.end = this.tokenizer.cursor;
+          return root;
+      }
+    }
+    root.end = this.tokenizer.cursor;
+    return root;
+  }
+  // Parse an identifier, which could be a stanza, assignment.
+  parseIdentifier() {
+    const token = this.tokenizer.next();
+    if (token.type !== "identifier") {
+      throw new Error(`Expected identifier but got ${token.type} at ${token.line}:${token.column}`);
+    }
+    const next = this.tokenizer.peek();
+    if (next.type === "curly" && next.value === "{") {
+      return this.parseStanza(token);
+    }
+    if (["string", "number", "boolean"].includes(next.type)) {
+      return this.parseStanza(token);
+    }
+    if (next.type === "operator" && next.value === "=") {
+      return this.parseAssignment(token);
+    }
+    this.errors.push({
+      expected: ["curly", "string", "operator"],
+      received: next.type,
+      message: `Expected {, argument or operator at ${next.line}:${next.column}`,
+      line: next.line,
+      column: next.column,
+      start: next.start,
+      end: next.end
+    });
+    return { type: "empty", line: next.line, column: next.column, start: next.start, end: next.end };
+  }
+  // Parse a stanza, which is a block of assignments and other
+  // stanzas.
+  parseStanza(token) {
+    const stanza = {
+      type: "stanza",
+      name: token.value,
+      args: [],
+      block: null,
+      line: token.line,
+      column: token.column,
+      start: token.start,
+      end: token.end
+    };
+    let next = this.tokenizer.peek();
+    while (next.type !== "curly") {
+      if (["string", "number", "boolean"].includes(next.type)) {
+        stanza.args.push(this.tokenizer.next());
+        next = this.tokenizer.peek();
+        continue;
+      }
+      this.errors.push({
+        expected: ["string", "number", "boolean"],
+        received: next.type,
+        message: `Expected argument at ${next.line}:${next.column}`,
+        line: next.line,
+        column: next.column,
+        start: next.start,
+        end: next.end
+      });
+      this.tokenizer.next();
+      next = this.tokenizer.peek();
+    }
+    this.expect("curly", "{");
+    stanza.block = this.parse();
+    this.expect("curly", "}");
+    stanza.end = this.tokenizer.cursor;
+    return stanza;
+  }
+  // Parse an assignment, which is an assignment to an expression.
+  parseAssignment(token) {
+    if (token.type !== "identifier") {
+      throw new Error(`Expected identifier but got ${token.type} at ${token.line}:${token.column}`);
+    }
+    const key = token;
+    const operator = this.expect("operator", "=");
+    const value = this.parseExpression();
+    return {
+      type: "assignment",
+      operator,
+      key,
+      value,
+      line: key.line,
+      column: key.column,
+      start: key.start,
+      end: value.end
+    };
+  }
+  // Parse an expression. We're not building a calculator (yet), so we
+  // just accept a value on the right for now.
+  parseExpression(ignore) {
+    const token = this.tokenizer.next(ignore || ["whitespace"]);
+    switch (token.type) {
+      case "string":
+      case "number":
+      case "boolean":
+        return token;
+      case "bracket":
+        if (token.value === "[") {
+          return this.parseArray();
+        }
+        break;
+      case "curly":
+        if (token.value === "{") {
+          return this.parseObject();
+        } else {
+          break;
+        }
+      default:
+        break;
+    }
+    this.errors.push({
+      expected: ["expression"],
+      received: token.type,
+      message: `Expected expression but got ${token.type}`,
+      line: token.line,
+      column: token.column,
+      start: token.start,
+      end: token.end
+    });
+    return {
+      type: "string",
+      value: '"<error>"',
+      line: token.line,
+      column: token.column,
+      start: token.start,
+      end: token.end
+    };
+  }
+  parseArray() {
+    const elements = [];
+    let next = this.tokenizer.peek(["whitespace", "newline"]);
+    if (next.type === "bracket" && next.value === "]") {
+      this.tokenizer.next(["whitespace", "newline"]);
+      return { type: "array", elements, line: next.line, column: next.column, start: next.start, end: next.end };
+    }
+    while (true) {
+      elements.push(this.parseExpression(["whitespace", "newline"]));
+      next = this.tokenizer.peek(["whitespace", "newline"]);
+      if (next.type === "bracket" && next.value === "]") {
+        this.tokenizer.next(["whitespace", "newline"]);
+        return { type: "array", elements, line: next.line, column: next.column, start: next.start, end: next.end };
+      }
+      next = this.tokenizer.peek(["whitespace", "newline"]);
+      if (next.type === "comma") {
+        this.tokenizer.next();
+        next = this.tokenizer.peek(["whitespace", "newline"]);
+        if (next.type === "bracket" && next.value === "]") {
+          this.tokenizer.next(["whitespace", "newline"]);
+          return { type: "array", elements, line: next.line, column: next.column, start: next.start, end: next.end };
+        }
+        continue;
+      }
+      this.errors.push({
+        expected: ["bracket", "comma"],
+        received: next.type,
+        message: `Expected ] or , but got ${next.type} at ${next.line}:${next.column}`,
+        line: next.line,
+        column: next.column,
+        start: next.start,
+        end: next.end
+      });
+      return { type: "array", elements, line: next.line, column: next.column, start: next.start, end: next.end };
+    }
+  }
+  parseObject() {
+    const properties = [];
+    let next = this.tokenizer.peek(["whitespace", "newline"]);
+    while (true) {
+      if (next.type === "end") {
+        this.errors.push({
+          expected: ["identifier"],
+          received: "end",
+          message: `Unexpected end of input at ${next.line}:${next.column}`,
+          line: next.line,
+          column: next.column,
+          start: next.start,
+          end: next.end
+        });
+        break;
+      }
+      if (next.type === "curly" && next.value === "}") {
+        this.tokenizer.next(["whitespace", "newline"]);
+        break;
+      }
+      if (next.type === "identifier" || next.type === "string") {
+        properties.push(this.parseProperty(this.tokenizer.next(["whitespace", "newline"])));
+        next = this.tokenizer.peek(["whitespace", "newline"]);
+        continue;
+      }
+      const token = this.tokenizer.next(["whitespace", "newline"]);
+      next = this.tokenizer.peek(["whitespace", "newline"]);
+      this.errors.push({
+        expected: ["identifier"],
+        received: next.type,
+        message: `Expected identifier but got ${token.type} at ${next.line}:${next.column}`,
+        line: next.line,
+        column: next.column,
+        start: next.start,
+        end: next.end
+      });
+    }
+    return { type: "object", properties, line: next.line, column: next.column, start: next.start, end: next.end };
+  }
+  parseProperty(token) {
+    if (token.type !== "identifier" && token.type !== "string") {
+      throw new Error(`Expected identifier or string but got ${token.type} at ${token.line}:${token.column}`);
+    }
+    const key = token;
+    const operator = this.expect("operator", "=");
+    const value = this.parseExpression();
+    return {
+      type: "property",
+      operator,
+      key,
+      value,
+      line: key.line,
+      column: key.column,
+      start: key.start,
+      end: value.end
+    };
+  }
+  // Expect a token of a certain type, optionally with a certain
+  // value.
+  expect(type, value) {
+    const token = this.tokenizer.peek();
+    if (token.type === "end" && type !== "end") {
+      this.errors.push({
+        expected: [type],
+        received: "end",
+        message: `Unexpected end of input at ${token.line}:${token.column}`,
+        line: token.line,
+        column: token.column,
+        start: token.start,
+        end: token.end
+      });
+      return this.tokenizer.next();
+    }
+    if (token.type !== type) {
+      this.errors.push({
+        expected: [type],
+        received: token.type,
+        message: `Expected ${type} but got ${token.type} at ${token.line}:${token.column}`,
+        line: token.line,
+        column: token.column,
+        start: token.start,
+        end: token.end
+      });
+      return {
+        type,
+        value: token.value,
+        start: token.start,
+        end: token.end,
+        line: token.line,
+        column: token.column
+      };
+    }
+    if (value && token.value !== value) {
+      this.errors.push({
+        message: `Expected ${value} but got ${token.value} at ${token.line}:${token.column}`,
+        line: token.line,
+        column: token.column,
+        start: token.start,
+        end: token.end
+      });
+      return {
+        type,
+        value,
+        start: token.start,
+        end: token.end,
+        line: token.line,
+        column: token.column
+      };
+    }
+    return this.tokenizer.next();
+  }
+};
+function fmt(ast, indent = 0, sibling) {
+  if (ast === null) {
+    return "";
+  }
+  const INDENT = " ".repeat(indent);
+  let str = "";
+  switch (ast.type) {
+    case "stanza":
+      str += `${INDENT}${ast.name} `;
+      for (const arg of ast.args) {
+        str += `${arg.value} `;
+      }
+      str += "{";
+      str += fmt(ast.block, indent + 2);
+      if (!ast.block?.children.every((child) => child.type === "newline")) {
+        str += `${INDENT}`;
+      }
+      str += "}";
+      break;
+    case "block":
+      if (ast.children.every((child) => child.type === "newline")) {
+      } else {
+        for (const child of ast.children) {
+          str += fmt(child, indent, sibling);
+          sibling = child;
+        }
+      }
+      break;
+    case "property":
+    case "assignment":
+      str += `${INDENT}${fmt(ast.key)} = ${fmt(ast.value)}`;
+      break;
+    case "expression":
+      str += `${fmt(ast.left)} ${ast.operator.value} ${fmt(ast.right)}`;
+      break;
+    case "comment":
+      if (sibling?.type !== "newline") {
+        str += `  `;
+      } else {
+        str += `${INDENT}`;
+      }
+      str += `${ast.value}`;
+      break;
+    case "empty":
+      break;
+    case "array":
+      const oneLine = `[${ast.elements.map((el) => fmt(el)).join(", ")}]`;
+      if (oneLine.length > 80) {
+        str += `[`;
+        for (const el of ast.elements) {
+          str += `
+${fmt(el, indent + 2)}`;
+        }
+        str += `
+${INDENT}]`;
+      } else {
+        return oneLine;
+      }
+      break;
+    case "object":
+      str += "{";
+      if (ast.properties.length > 0) {
+        str += "\n";
+        for (const assign of ast.properties) {
+          str += `${fmt(assign, indent + 2)}
+`;
+        }
+        str += `
+${INDENT}}`;
+      }
+      break;
+    default:
+      str += `${ast?.value}`;
+  }
+  return str;
+}
+
+// ../drizzle/dist/appify/build.js
+function valueOf(token) {
+  if (token.type === "number") {
+    return Number(token.value);
+  }
+  if (token.type === "boolean") {
+    return token.value == "true";
+  }
+  if (token.type === "string") {
+    return token.value.slice(1, -1);
+  }
+  throw new Error(`unexpected token type: ${token}`);
+}
+var EMPTY_CONFIG_OBJECT = {
+  line: 0,
+  column: 0,
+  start: 0,
+  end: 0
+};
+var ConfigError = class {
+  message;
+  line;
+  column;
+  start;
+  end;
+  constructor(message, obj) {
+    this.message = message;
+    this.line = obj.line;
+    this.column = obj.column;
+    this.start = obj.start;
+    this.end = obj.end;
+  }
+};
+function buildManifest(node) {
+  const applications = [];
+  const errors = [];
+  for (const child of node.children) {
+    switch (child.type) {
+      case "stanza":
+        if (child.name === "application") {
+          buildStanza(buildApplication, child, applications, errors);
+        } else {
+          errors.push({ message: "expected application", ...child });
+        }
+        break;
+      case "comment":
+      case "newline":
+        break;
+      default:
+        errors.push({ message: "expected application", ...child });
+    }
+  }
+  return [applications, errors];
+}
+function buildName0(stanzaName, node) {
+  const errors = [];
+  if (node.args.length > 0) {
+    errors.push({ message: `${stanzaName} does not take a name argument`, ...node.args[0] });
+  }
+  return [
+    {
+      type: "string",
+      value: `"${stanzaName}"`,
+      line: node.line,
+      column: node.column,
+      start: node.start,
+      end: node.block?.start || node.end
+    },
+    errors
+  ];
+}
+function buildName1(node) {
+  const errors = [];
+  const invalid = {
+    type: "string",
+    value: '"<invalid>"',
+    line: node.line,
+    column: node.column,
+    start: node.start,
+    end: node.block?.start || node.end
+  };
+  if (node.args.length === 0) {
+    errors.push({ message: "expected name", ...node });
+    return [invalid, errors];
+  }
+  if (node.args.length > 1) {
+    errors.push({ message: "unexpected additional args", ...node });
+  }
+  if (node.args[0]?.type !== "string") {
+    errors.push({ message: "expected string", ...node.args[0] });
+    return [invalid, errors];
+  }
+  return [node.args[0], errors];
+}
+function buildOptionalName(node) {
+  const errors = [];
+  if (node.args.length === 0) {
+    return [void 0, errors];
+  }
+  if (node.args.length > 1) {
+    errors.push({ message: "unexpected additional args", ...node });
+  }
+  if (node.args[0]?.type !== "string") {
+    errors.push({ message: "expected string", ...node.args[0] });
+    return [void 0, errors];
+  }
+  return [node.args[0], errors];
+}
+function buildStanza(handler, child, into, errors) {
+  const [buildItem, buildErrors] = handler(child);
+  if (buildItem) {
+    into.push(buildItem);
+  }
+  errors.push(...buildErrors);
+}
+function buildAssignment(obj, field, expected, child, errors) {
+  if (obj[field]) {
+    errors.push({ message: `duplicate ${fmt(child.key)} assignment ${fmt(child.value)}`, ...child.key });
+  }
+  if (child.value.type !== expected) {
+    errors.push({ message: `expected ${expected}`, ...child.value });
+  } else {
+    obj[field] = child.value;
+  }
+}
+function buildLabelset(target, field, child, errors) {
+  if (child.value.type !== "object") {
+    errors.push({ message: `${child.key.value} must be an object`, ...child });
+    return;
+  }
+  if (!target[field]) {
+    target[field] = {};
+  }
+  const labelset = target[field];
+  for (const prop of child.value.properties) {
+    const key = prop.key.type === "string" ? valueOf(prop.key) : prop.key.value;
+    if (prop.value.type === "string") {
+      labelset[key] = valueOf(prop.value);
+    } else {
+      errors.push({
+        message: `${child.key.value} must have string values, found non-string value for key "${prop.key.value}"`,
+        ...prop.value
+      });
+    }
+  }
+}
+function buildApplication(node) {
+  const errors = [];
+  const [name, nameErrors] = buildName1(node);
+  errors.push(...nameErrors);
+  const app = new Application(name, node);
+  const children = node.block ? node.block.children : [];
+  for (const child of children) {
+    switch (child.type) {
+      case "stanza":
+        switch (child.name) {
+          case "service":
+            buildStanza(buildService, child, app.service, errors);
+            break;
+          case "mcp_service":
+            buildStanza(buildMcpService, child, app.mcpService, errors);
+            break;
+          case "env":
+            buildStanza(buildEnv, child, app.env, errors);
+            break;
+          case "observer":
+            buildStanza(buildObserver, child, app.observer, errors);
+            break;
+          case "actor":
+            buildStanza(buildActor, child, app.actor, errors);
+            break;
+          case "task":
+            buildStanza(buildTask, child, app.task, errors);
+            break;
+          case "bucket":
+            buildStanza(buildBucket, child, app.bucket, errors);
+            break;
+          case "queue":
+            buildStanza(buildQueue, child, app.queue, errors);
+            break;
+          case "vector_index":
+            buildStanza(buildVectorIndex, child, app.vectorIndex, errors);
+            break;
+          case "sql_database":
+            buildStanza(buildSqlDatabase, child, app.sqlDatabase, errors);
+            break;
+          case "kv_cache":
+            buildStanza(buildKvCache, child, app.kvCache, errors);
+            break;
+          case "kv_store":
+            buildStanza(buildKvCache, child, app.kvCache, errors);
+            break;
+          case "smartbucket":
+            buildStanza(buildSmartBucket, child, app.smartBucket, errors);
+            break;
+          case "smartsql":
+            buildStanza(buildSmartSql, child, app.smartSql, errors);
+            break;
+          case "smartmemory":
+            buildStanza(buildSmartMemory, child, app.smartMemory, errors);
+            break;
+          case "payments":
+            buildStanza(buildPayments, child, app.payments, errors);
+            break;
+          default:
+            errors.push({ message: "unexpected stanza", ...child });
+        }
+        break;
+      case "assignment":
+        switch (child.key.value) {
+          case "labels":
+            buildLabelset(app, "labels", child, errors);
+            break;
+          default:
+            errors.push({ message: "unexpected assignment", ...child });
+        }
+        break;
+      case "comment":
+        break;
+      case "newline":
+        break;
+      default:
+        errors.push({ message: `unexpected ${child.type}`, ...child });
+    }
+  }
+  return [app, errors];
+}
+function buildService(stanza) {
+  const errors = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const service = new Service(name, stanza);
+  const children = stanza.block ? stanza.block.children : [];
+  for (const child of children) {
+    switch (child.type) {
+      case "stanza":
+        switch (child.name) {
+          case "route":
+            buildStanza(buildRoute, child, service.routes, errors);
+            break;
+          case "domain":
+            buildStanza(buildDomain, child, service.domains, errors);
+            break;
+          case "binding":
+            buildStanza(buildBinding, child, service.bindings, errors);
+            break;
+          case "env":
+            buildStanza(buildEnv, child, service.env, errors);
+            break;
+          default:
+            errors.push({ message: "unexpected stanza", ...child });
+        }
+        break;
+      case "assignment":
+        switch (child.key.value) {
+          case "visibility":
+            buildAssignment(service, "visibility", "string", child, errors);
+            break;
+          case "labels":
+            buildLabelset(service, "labels", child, errors);
+            break;
+          default:
+            errors.push({ message: "unexpected assignment", ...child });
+        }
+        break;
+      case "comment":
+      case "newline":
+        break;
+      default:
+        errors.push({ message: "unexpected node", ...child });
+    }
+  }
+  return [service, errors];
+}
+function buildMcpService(stanza) {
+  const errors = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const service = new McpService(name, stanza);
+  const children = stanza.block ? stanza.block.children : [];
+  for (const child of children) {
+    switch (child.type) {
+      case "stanza":
+        switch (child.name) {
+          case "route":
+            buildStanza(buildRoute, child, service.routes, errors);
+            break;
+          case "domain":
+            buildStanza(buildDomain, child, service.domains, errors);
+            break;
+          case "binding":
+            buildStanza(buildBinding, child, service.bindings, errors);
+            break;
+          case "env":
+            buildStanza(buildEnv, child, service.env, errors);
+            break;
+          default:
+            errors.push({ message: "unexpected stanza", ...child });
+        }
+        break;
+      case "assignment":
+        switch (child.key.value) {
+          case "visibility":
+            buildAssignment(service, "visibility", "string", child, errors);
+            break;
+          case "authorization_server":
+            buildAssignment(service, "authorizationServer", "string", child, errors);
+            break;
+          case "jwks_url":
+            buildAssignment(service, "jwksUrl", "string", child, errors);
+            break;
+          case "labels":
+            buildLabelset(service, "labels", child, errors);
+            break;
+          default:
+            errors.push({ message: "unexpected assignment", ...child });
+        }
+        break;
+      case "comment":
+      case "newline":
+        break;
+      default:
+        errors.push({ message: "unexpected node", ...child });
+    }
+  }
+  return [service, errors];
+}
+function buildBucket(stanza) {
+  const errors = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const bucket = new Bucket(name, stanza);
+  for (const child of stanza.block?.children ?? []) {
+    switch (child.type) {
+      case "stanza":
+        errors.push({ message: "unexpected stanza", ...child });
+        break;
+      case "assignment":
+        switch (child.key.value) {
+          case "visibility":
+            buildAssignment(bucket, "visibility", "string", child, errors);
+            break;
+          case "location_hint":
+            buildAssignment(bucket, "locationHint", "string", child, errors);
+            break;
+          default:
+            errors.push({ message: "unexpected assignment", ...child });
+        }
+        break;
+      case "comment":
+      case "newline":
+        break;
+      default:
+        errors.push({ message: `unexpected ${child.type}`, ...child });
+    }
+  }
+  return [bucket, errors];
+}
+function buildQueue(stanza) {
+  const errors = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const queue = new Queue(name, stanza);
+  for (const child of stanza.block?.children ?? []) {
+    switch (child.type) {
+      case "stanza":
+        errors.push({ message: "unexpected stanza", ...child });
+        break;
+      case "assignment":
+        switch (child.key.value) {
+          case "visibility":
+            buildAssignment(queue, "visibility", "string", child, errors);
+            break;
+          default:
+            errors.push({ message: "unexpected assignment", ...child });
+        }
+        break;
+      case "comment":
+      case "newline":
+        break;
+      default:
+        errors.push({ message: `unexpected ${child.type}`, ...child });
+    }
+  }
+  return [queue, errors];
+}
+function buildVectorIndex(stanza) {
+  const errors = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const bucket = new VectorIndex(name, stanza);
+  for (const child of stanza.block?.children ?? []) {
+    switch (child.type) {
+      case "stanza":
+        errors.push({ message: "unexpected stanza", ...child });
+        break;
+      case "assignment":
+        switch (child.key.value) {
+          case "visibility":
+            buildAssignment(bucket, "visibility", "string", child, errors);
+            break;
+          case "dimensions":
+            buildAssignment(bucket, "dimensions", "number", child, errors);
+            break;
+          case "metric":
+            buildAssignment(bucket, "metric", "string", child, errors);
+            break;
+          default:
+            errors.push({ message: "unexpected assignment", ...child });
+        }
+        break;
+      case "comment":
+      case "newline":
+        break;
+      default:
+        errors.push({ message: `unexpected ${child.type}`, ...child });
+    }
+  }
+  return [bucket, errors];
+}
+function buildSqlDatabase(stanza) {
+  const errors = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const sqlDatabase = new SqlDatabase(name, stanza);
+  for (const child of stanza.block?.children ?? []) {
+    switch (child.type) {
+      case "stanza":
+        errors.push({ message: "unexpected stanza", ...child });
+        break;
+      case "assignment":
+        switch (child.key.value) {
+          case "disable_prisma":
+            buildAssignment(sqlDatabase, "disable_prisma", "boolean", child, errors);
+            break;
+          case "visibility":
+            buildAssignment(sqlDatabase, "visibility", "string", child, errors);
+            break;
+          default:
+            errors.push({ message: "unexpected assignment", ...child });
+        }
+        break;
+      case "comment":
+      case "newline":
+        break;
+      default:
+        errors.push({ message: `unexpected ${child.type}`, ...child });
+    }
+  }
+  return [sqlDatabase, errors];
+}
+function buildKvCache(stanza) {
+  const errors = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const kvCache = new KvCache(name, stanza);
+  for (const child of stanza.block?.children ?? []) {
+    switch (child.type) {
+      case "stanza":
+        errors.push({ message: "unexpected stanza", ...child });
+        break;
+      case "assignment":
+        switch (child.key.value) {
+          case "visibility":
+            buildAssignment(kvCache, "visibility", "string", child, errors);
+            break;
+          default:
+            errors.push({ message: "unexpected assignment", ...child });
+        }
+        break;
+      case "comment":
+      case "newline":
+        break;
+      default:
+        errors.push({ message: `unexpected ${child.type}`, ...child });
+    }
+  }
+  return [kvCache, errors];
+}
+function buildSmartBucket(stanza) {
+  const errors = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const smartBucket = new SmartBucket(name, stanza);
+  for (const child of stanza.block?.children ?? []) {
+    switch (child.type) {
+      case "assignment":
+        switch (child.key.value) {
+          case "location_hint":
+            buildAssignment(smartBucket, "locationHint", "string", child, errors);
+            break;
+          default:
+            errors.push({ message: "unexpected assignment", ...child });
+        }
+        break;
+      case "comment":
+      case "newline":
+        break;
+      default:
+        errors.push({ message: `unexpected ${child.type}`, ...child });
+    }
+  }
+  return [smartBucket, errors];
+}
+function buildSmartSql(stanza) {
+  const errors = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const smartSql = new SmartSql(name, stanza);
+  for (const child of stanza.block?.children ?? []) {
+    switch (child.type) {
+      case "assignment":
+        switch (child.key.value) {
+          case "location_hint":
+            buildAssignment(smartSql, "locationHint", "string", child, errors);
+            break;
+          default:
+            errors.push({ message: "unexpected assignment", ...child });
+        }
+        break;
+    }
+  }
+  return [smartSql, errors];
+}
+function buildSmartMemory(stanza) {
+  const errors = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const smartMemory = new SmartMemory(name, stanza);
+  for (const child of stanza.block?.children ?? []) {
+    switch (child.type) {
+      case "comment":
+      case "newline":
+        break;
+      default:
+        errors.push({ message: `unexpected ${child.type}`, ...child });
+    }
+  }
+  return [smartMemory, errors];
+}
+function buildPayments(stanza) {
+  const errors = [];
+  const [name, nameErrors] = buildName0("payments", stanza);
+  errors.push(...nameErrors);
+  const payments = new Payments(name, stanza);
+  for (const child of stanza.block?.children ?? []) {
+    switch (child.type) {
+      case "assignment":
+        switch (child.key.value) {
+          case "mode":
+            buildAssignment(payments, "mode", "string", child, errors);
+            if (payments.mode && child.value.type === "string") {
+              const modeValue = valueOf(payments.mode);
+              if (modeValue !== "live" && modeValue !== "test") {
+                errors.push({
+                  message: `mode must be either "live" or "test", got "${modeValue}"`,
+                  ...child.value
+                });
+              }
+            }
+            break;
+          default:
+            errors.push({ message: "unexpected assignment", ...child });
+        }
+        break;
+      case "comment":
+      case "newline":
+        break;
+      default:
+        errors.push({ message: `unexpected ${child.type}`, ...child });
+    }
+  }
+  return [payments, errors];
+}
+function buildObserver(stanza) {
+  const errors = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const observer = new Observer(name, stanza);
+  const children = stanza.block ? stanza.block.children : [];
+  for (const child of children) {
+    switch (child.type) {
+      case "stanza":
+        switch (child.name) {
+          case "source":
+            buildStanza(buildSource, child, observer.source, errors);
+            break;
+          case "binding":
+            buildStanza(buildBinding, child, observer.bindings, errors);
+            break;
+          case "env":
+            buildStanza(buildEnv, child, observer.env, errors);
+            break;
+          default:
+            errors.push({ message: "unexpected stanza", ...child });
+        }
+        break;
+      case "assignment":
+        switch (child.key.value) {
+          case "labels":
+            buildLabelset(observer, "labels", child, errors);
+            break;
+          default:
+            errors.push({ message: "unexpected assignment", ...child });
+        }
+        break;
+      case "comment":
+      case "newline":
+        break;
+      default:
+        errors.push({ message: `unexpected ${child.type}`, ...child });
+    }
+  }
+  return [observer, errors];
+}
+function buildActor(stanza) {
+  const errors = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const actor = new Actor(name, stanza);
+  const children = stanza.block ? stanza.block.children : [];
+  for (const child of children) {
+    switch (child.type) {
+      case "stanza":
+        switch (child.name) {
+          case "route":
+            buildStanza(buildRoute, child, actor.routes, errors);
+            break;
+          case "domain":
+            buildStanza(buildDomain, child, actor.domains, errors);
+            break;
+          case "binding":
+            buildStanza(buildBinding, child, actor.bindings, errors);
+            break;
+          case "env":
+            buildStanza(buildEnv, child, actor.env, errors);
+            break;
+          default:
+            errors.push({ message: "unexpected stanza", ...child });
+        }
+        break;
+      case "assignment":
+        switch (child.key.value) {
+          case "visibility":
+            buildAssignment(actor, "visibility", "string", child, errors);
+            break;
+          case "labels":
+            buildLabelset(actor, "labels", child, errors);
+            break;
+          default:
+            errors.push({ message: "unexpected assignment", ...child });
+        }
+        break;
+      case "comment":
+        break;
+      case "newline":
+        break;
+      default:
+        errors.push({ message: `unexpected ${child.type}`, ...child });
+    }
+  }
+  return [actor, errors];
+}
+function buildTask(stanza) {
+  const errors = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const task = new Task(name, stanza);
+  const children = stanza.block ? stanza.block.children : [];
+  for (const child of children) {
+    switch (child.type) {
+      case "stanza":
+        switch (child.name) {
+          case "binding":
+            buildStanza(buildBinding, child, task.bindings, errors);
+            break;
+          case "env":
+            buildStanza(buildEnv, child, task.env, errors);
+            break;
+          default:
+            errors.push({ message: "unexpected stanza", ...child });
+        }
+        break;
+      case "assignment":
+        switch (child.key.value) {
+          case "type":
+            buildAssignment(task, "type", "string", child, errors);
+            break;
+          case "cron":
+            buildAssignment(task, "cron", "string", child, errors);
+            break;
+          case "visibility":
+            buildAssignment(task, "visibility", "string", child, errors);
+            break;
+          default:
+            errors.push({ message: "unexpected assignment", ...child });
+        }
+        break;
+    }
+  }
+  return [task, errors];
+}
+function buildSource(stanza) {
+  const errors = [];
+  const source = new Source(stanza);
+  for (const child of stanza.block?.children ?? []) {
+    if (child.type === "assignment") {
+      switch (child.key.value) {
+        case "bucket":
+          buildAssignment(source, "bucket", "string", child, errors);
+          break;
+        case "queue":
+          buildAssignment(source, "queue", "string", child, errors);
+          break;
+        case "batch_size":
+          buildAssignment(source, "batchSize", "number", child, errors);
+          break;
+        case "max_wait_time_ms":
+          buildAssignment(source, "maxWaitTimeMs", "number", child, errors);
+          break;
+        case "max_retries":
+          buildAssignment(source, "maxRetries", "number", child, errors);
+          break;
+        default:
+          errors.push({ message: "unexpected assignment", ...child });
+      }
+    } else if (child.type === "stanza") {
+      if (child.name === "rule") {
+        source.rule = source.rule ?? [];
+        const rule = new Rule(child);
+        for (const ruleChild of child.block?.children ?? []) {
+          if (ruleChild.type === "stanza") {
+            errors.push({ message: "unexpected stanza", ...ruleChild });
+          } else if (ruleChild.type === "assignment") {
+            switch (ruleChild.key.value) {
+              case "actions":
+                buildAssignment(rule, "actions", "array", ruleChild, errors);
+                break;
+              case "prefix":
+                buildAssignment(rule, "prefix", "string", ruleChild, errors);
+                break;
+              case "suffix":
+                buildAssignment(rule, "suffix", "string", ruleChild, errors);
+                break;
+              default:
+                errors.push({ message: "unexpected assignment", ...ruleChild });
+            }
+          }
+        }
+        source.rule.push(rule);
+      } else {
+        errors.push({ message: "unexpected stanza", ...child });
+      }
+    }
+  }
+  return [source, errors];
+}
+function buildRoute(stanza) {
+  const errors = [];
+  const [name, nameErrors] = buildOptionalName(stanza);
+  errors.push(...nameErrors);
+  const route = new Route(stanza, name);
+  for (const child of stanza.block?.children ?? []) {
+    if (child.type === "assignment") {
+      switch (child.key.value) {
+        case "cname":
+          buildAssignment(route, "cname", "string", child, errors);
+          break;
+        case "domain":
+          buildAssignment(route, "domain", "string", child, errors);
+          break;
+        case "path":
+          buildAssignment(route, "path", "string", child, errors);
+          break;
+        case "zone":
+          buildAssignment(route, "zone", "string", child, errors);
+          break;
+        default:
+          errors.push({ message: `unexpected assignment ${child.key}`, ...child });
+      }
+    }
+  }
+  if (route.cname && route.domain) {
+    errors.push({ message: "cname cannot be used with domain", ...stanza });
+  }
+  return [route, errors];
+}
+function buildDomain(stanza) {
+  const errors = [];
+  const [name, nameErrors] = buildOptionalName(stanza);
+  errors.push(...nameErrors);
+  const domain = new Domain(stanza, name);
+  for (const child of stanza.block?.children ?? []) {
+    if (child.type === "assignment") {
+      switch (child.key.value) {
+        case "cname":
+          buildAssignment(domain, "cname", "string", child, errors);
+          break;
+        case "fqdn":
+          buildAssignment(domain, "fqdn", "string", child, errors);
+          break;
+        default:
+          errors.push({ message: `unexpected assignment ${child.key}`, ...child });
+      }
+    }
+  }
+  return [domain, errors];
+}
+function buildBinding(stanza) {
+  const errors = [];
+  const bindings = [];
+  function hasBinding(key) {
+    return bindings.some((binding) => binding.key.value === key);
+  }
+  for (const child of stanza.block?.children ?? []) {
+    if (child.type === "assignment") {
+      if (hasBinding(child.key.value)) {
+        errors.push({ message: `duplicate binding ${child.key.value}`, ...child.key });
+      }
+      if (child.value.type === "string") {
+        bindings.push(child);
+      } else {
+        errors.push({ message: "expected string", ...child.value });
+      }
+    }
+  }
+  return [new Binding(bindings, stanza), errors];
+}
+function buildEnv(stanza) {
+  const errors = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const env = new Env(name, stanza);
+  for (const child of stanza.block?.children ?? []) {
+    if (child.type === "assignment") {
+      switch (child.key.value) {
+        case "secret":
+          buildAssignment(env, "secret", "boolean", child, errors);
+          break;
+        case "default":
+          buildAssignment(env, "default", "string", child, errors);
+          break;
+        default:
+          errors.push({ message: `unexpected assignment ${child.key}`, ...child });
+      }
+    }
+  }
+  return [env, errors];
+}
+var Application = class {
+  obj;
+  name;
+  service = [];
+  observer = [];
+  actor = [];
+  task = [];
+  bucket = [];
+  queue = [];
+  env = [];
+  sqlDatabase = [];
+  vectorIndex = [];
+  kvCache = [];
+  // Backward compatibility: kvStore points to the same array as kvCache
+  get kvStore() {
+    return this.kvCache;
+  }
+  set kvStore(value) {
+    this.kvCache = value;
+  }
+  smartBucket = [];
+  smartSql = [];
+  smartMemory = [];
+  payments = [];
+  labels = {};
+  mcpService = [];
+  constructor(name, obj) {
+    this.name = name;
+    this.obj = obj;
+  }
+  // Return all objects that require code handlers.
+  handlers() {
+    return [...this.service, ...this.observer, ...this.actor, ...this.task, ...this.mcpService];
+  }
+};
+var Service = class {
+  obj;
+  name;
+  visibility;
+  routes = [];
+  domains = [];
+  bindings = [];
+  env = [];
+  labels = {};
+  constructor(name, obj) {
+    this.name = name;
+    this.obj = obj;
+  }
+};
+var Actor = class {
+  obj;
+  name;
+  routes = [];
+  domains = [];
+  bindings = [];
+  env = [];
+  visibility;
+  labels = {};
+  constructor(name, obj) {
+    this.name = name;
+    this.obj = obj;
+  }
+};
+var McpService = class {
+  obj;
+  name;
+  visibility;
+  routes = [];
+  domains = [];
+  bindings = [];
+  env = [];
+  authorizationServer;
+  jwksUrl;
+  labels = {};
+  constructor(name, obj) {
+    this.name = name;
+    this.obj = obj;
+  }
+};
+var Task = class {
+  obj;
+  name;
+  type;
+  cron;
+  bindings = [];
+  env = [];
+  visibility;
+  constructor(name, obj) {
+    this.name = name;
+    this.obj = obj;
+  }
+};
+var Observer = class {
+  obj;
+  name;
+  source = [];
+  bindings = [];
+  env = [];
+  labels = {};
+  constructor(name, obj) {
+    this.name = name;
+    this.obj = obj;
+  }
+};
+var Source = class {
+  obj;
+  bucket;
+  rule;
+  queue;
+  batchSize;
+  maxWaitTimeMs;
+  maxRetries;
+  constructor(obj) {
+    this.obj = obj;
+  }
+};
+var Rule = class {
+  obj;
+  actions;
+  prefix;
+  suffix;
+  constructor(obj) {
+    this.obj = obj;
+  }
+};
+var Route = class {
+  obj;
+  name;
+  zone;
+  domain;
+  cname;
+  path;
+  constructor(obj, name) {
+    this.obj = obj;
+    this.name = name;
+  }
+};
+var Domain = class {
+  obj;
+  name;
+  cname;
+  fqdn;
+  constructor(obj, name) {
+    this.obj = obj;
+    this.name = name;
+  }
+};
+var Binding = class {
+  bindings;
+  obj;
+  constructor(bindings, obj) {
+    this.bindings = bindings;
+    this.obj = obj;
+  }
+};
+var Env = class {
+  name;
+  secret;
+  default;
+  obj;
+  constructor(name, obj) {
+    this.name = name;
+    this.obj = obj;
+  }
+};
+var Bucket = class {
+  name;
+  visibility;
+  locationHint;
+  obj;
+  constructor(name, obj) {
+    this.name = name;
+    this.obj = obj;
+  }
+};
+var KvCache = class {
+  name;
+  visibility;
+  obj;
+  constructor(name, obj) {
+    this.name = name;
+    this.obj = obj;
+  }
+};
+var KvStore = class extends KvCache {
+};
+var Queue = class {
+  name;
+  visibility;
+  obj;
+  constructor(name, obj) {
+    this.name = name;
+    this.obj = obj;
+  }
+};
+var VectorIndex = class {
+  name;
+  visibility;
+  dimensions;
+  metric;
+  obj;
+  constructor(name, obj) {
+    this.name = name;
+    this.obj = obj;
+  }
+};
+var SqlDatabase = class {
+  name;
+  schema;
+  visibility;
+  disable_prisma;
+  obj;
+  constructor(name, obj) {
+    this.name = name;
+    this.obj = obj;
+  }
+};
+var SmartBucket = class {
+  name;
+  locationHint;
+  obj;
+  constructor(name, obj) {
+    this.name = name;
+    this.obj = obj;
+  }
+};
+var SmartSql = class {
+  name;
+  locationHint;
+  obj;
+  constructor(name, obj) {
+    this.name = name;
+    this.obj = obj;
+  }
+};
+var SmartMemory = class {
+  name;
+  obj;
+  constructor(name, obj) {
+    this.name = name;
+    this.obj = obj;
+  }
+};
+var Payments = class {
+  name;
+  obj;
+  mode;
+  constructor(name, obj) {
+    this.name = name;
+    this.obj = obj;
+  }
+};
+var VISIBILITIES = ["none", "public", "private", "protected", "paid", "application", "suite", "tenant"];
+var TASK_TYPES = ["cron"];
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM,
+  init_cjs_shims,
+  Tokenizer,
+  Parser,
+  fmt,
+  valueOf,
+  EMPTY_CONFIG_OBJECT,
+  ConfigError,
+  buildManifest,
+  buildApplication,
+  Application,
+  Service,
+  Actor,
+  McpService,
+  Task,
+  Observer,
+  Source,
+  Rule,
+  Route,
+  Domain,
+  Binding,
+  Env,
+  Bucket,
+  KvCache,
+  KvStore,
+  Queue,
+  VectorIndex,
+  SqlDatabase,
+  SmartBucket,
+  SmartSql,
+  SmartMemory,
+  Payments,
+  VISIBILITIES,
+  TASK_TYPES
+};