@lunora/server 0.0.0 → 1.0.0-alpha.1

package/dist/packem_shared/definePresence-D5LtwGl0.mjs

@@ -0,0 +1,114 @@
+import { v } from '@lunora/values';
+import { initLunora } from './initLunora-CATvPsVt.mjs';
+import { LunoraError } from './LunoraError-DhggBJZF.mjs';
+import { onDisconnect } from './onConnect-CIPXKPyw.mjs';
+import { defineSchemaExtension, defineComponent } from './defineSchemaExtension-Ck5_TUO8.mjs';
+import { defineTable } from './defineAggregateIndex-DzqxtAyV.mjs';
+
+const DEFAULT_TTL_MS = 3e4;
+const MAX_DATA_BYTES = 4096;
+const PRESENCE_KEY = "presence";
+const PRESENCE_BARE_TABLE = "present";
+const PRESENCE_TABLE = `${PRESENCE_KEY}_${PRESENCE_BARE_TABLE}`;
+const presenceExtension = defineSchemaExtension(PRESENCE_KEY, {
+  tables: {
+    [PRESENCE_BARE_TABLE]: defineTable({
+      data: v.optional(v.record(v.string(), v.any())),
+      lastSeen: v.number(),
+      roomId: v.string(),
+      sessionId: v.string(),
+      userId: v.optional(v.string())
+    }).index("byRoomSession", ["roomId", "sessionId"]).index("byRoom", ["roomId"])
+  }
+});
+const { mutation, query } = initLunora.dataModel().create();
+const definePresence = (options = {}) => {
+  const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+  const disconnectGraceMs = Math.max(0, Math.min(options.disconnectGraceMs ?? 0, ttlMs));
+  const heartbeat = mutation.input({
+    data: v.optional(v.record(v.string(), v.any())),
+    roomId: v.string(),
+    sessionId: v.string()
+  }).mutation(async ({ args, ctx: context }) => {
+    const lastSeen = Date.now();
+    const userId = context.auth.userId ?? void 0;
+    if (args.data !== void 0 && JSON.stringify(args.data).length > MAX_DATA_BYTES) {
+      throw new LunoraError("BAD_REQUEST", `presence data exceeds the ${String(MAX_DATA_BYTES)}-byte limit`);
+    }
+    const existing = await context.db.query(PRESENCE_TABLE).withIndex("byRoomSession", (q) => q.eq("roomId", args.roomId).eq("sessionId", args.sessionId)).first();
+    if (existing && (existing["userId"] ?? void 0) !== userId) {
+      throw new LunoraError("FORBIDDEN", "presence heartbeat denied: this (roomId, sessionId) is held by another identity");
+    }
+    const row = {
+      lastSeen,
+      roomId: args.roomId,
+      sessionId: args.sessionId,
+      ...args.data === void 0 ? {} : { data: args.data },
+      ...userId === void 0 ? {} : { userId }
+    };
+    await (existing ? context.db.patch(existing["_id"], row) : context.db.insert(PRESENCE_TABLE, row));
+    return { lastSeen };
+  });
+  const listPresent = query.input({ roomId: v.string() }).query(async ({ args, ctx: context }) => {
+    const cutoff = Date.now() - ttlMs;
+    const rows = await context.db.query(PRESENCE_TABLE).withIndex("byRoom", (q) => q.eq("roomId", args.roomId)).collect();
+    const live = rows.filter((row) => row["lastSeen"] > cutoff).toSorted((a, b) => b["lastSeen"] - a["lastSeen"]);
+    const seenUsers = /* @__PURE__ */ new Set();
+    const members = [];
+    for (const row of live) {
+      const userId = row["userId"];
+      if (userId !== void 0) {
+        if (seenUsers.has(userId)) {
+          continue;
+        }
+        seenUsers.add(userId);
+      }
+      const member = {
+        lastSeen: row["lastSeen"],
+        roomId: row["roomId"]
+      };
+      if (userId !== void 0) {
+        member.userId = userId;
+      }
+      if (row["data"] !== void 0) {
+        member.data = row["data"];
+      }
+      members.push(member);
+    }
+    return members;
+  });
+  const sweep = mutation.input({ roomId: v.string() }).mutation(async ({ args, ctx: context }) => {
+    const cutoff = Date.now() - ttlMs;
+    const stale = await context.db.query(PRESENCE_TABLE).withIndex("byRoom", (q) => q.eq("roomId", args.roomId)).filter((row) => row["lastSeen"] <= cutoff).collect();
+    await Promise.all(stale.map((row) => context.db.delete(row["_id"])));
+    return { deleted: stale.length };
+  });
+  const internalSweep = { ...sweep, visibility: "internal" };
+  const disconnect = onDisconnect(async (context, event) => {
+    const roomId = event.context?.["roomId"];
+    const sessionId = event.context?.["sessionId"];
+    if (typeof roomId !== "string" || typeof sessionId !== "string") {
+      return;
+    }
+    const existing = await context.db.query(PRESENCE_TABLE).withIndex("byRoomSession", (q) => q.eq("roomId", roomId).eq("sessionId", sessionId)).first();
+    if (!existing) {
+      return;
+    }
+    const verifiedUserId = event.userId ?? void 0;
+    if ((existing["userId"] ?? void 0) !== verifiedUserId) {
+      return;
+    }
+    if (disconnectGraceMs === 0) {
+      await context.db.delete(existing["_id"]);
+      return;
+    }
+    const agedLastSeen = Math.min(existing["lastSeen"], Date.now() + disconnectGraceMs - ttlMs);
+    await context.db.patch(existing["_id"], { lastSeen: agedLastSeen });
+  });
+  return defineComponent(PRESENCE_KEY, {
+    extension: presenceExtension,
+    functions: { disconnect, heartbeat, listPresent, sweep: internalSweep }
+  });
+};
+
+export { DEFAULT_TTL_MS as PRESENCE_DEFAULT_TTL_MS, PRESENCE_TABLE, definePresence, presenceExtension };

package/dist/packem_shared/defineSchemaExtension-Ck5_TUO8.mjs

@@ -0,0 +1,100 @@
+import { r as runMiddlewareChain } from './run-middleware-CYQOuoV6.mjs';
+
+const prefixTableName = (key, bareName) => `${key}_${bareName}`;
+const rewriteReference = (target, key, bareNames) => bareNames.has(target) ? prefixTableName(key, target) : target;
+const rewriteTableReferences = (table, key, bareNames, ownBareName) => {
+  const ownPrefixed = prefixTableName(key, ownBareName);
+  const rewriteOn = (on) => on === "" ? ownPrefixed : rewriteReference(on, key, bareNames);
+  const relationMap = {};
+  for (const [accessor, relation] of Object.entries(table.relationMap)) {
+    relationMap[accessor] = { ...relation, table: rewriteReference(relation.table, key, bareNames) };
+  }
+  const aggregateIndexes = table.aggregateIndexes.map((index) => {
+    return { ...index, on: rewriteOn(index.on) };
+  });
+  const rankIndexes = table.rankIndexes.map((index) => {
+    return { ...index, on: rewriteOn(index.on) };
+  });
+  return { ...table, aggregateIndexes, rankIndexes, relationMap };
+};
+const defineSchemaExtension = (key, options) => {
+  if (!key) {
+    throw new Error("defineSchemaExtension: `key` is required and must be a non-empty string");
+  }
+  return {
+    key,
+    tables: options.tables,
+    ...options.vectorIndexes ? { vectorIndexes: options.vectorIndexes } : {}
+  };
+};
+const definePlugin = (key, options) => {
+  if (!key) {
+    throw new Error("definePlugin: `key` is required and must be a non-empty string");
+  }
+  if (options.extension && options.extension.key !== key) {
+    throw new Error(`definePlugin("${key}"): extension key "${options.extension.key}" does not match plugin key`);
+  }
+  return {
+    key,
+    ...options.extension ? { extension: options.extension } : {},
+    ...options.middleware ? { middleware: options.middleware } : {}
+  };
+};
+const defineComponent = (key, options) => {
+  const plugin = definePlugin(key, {
+    ...options.extension ? { extension: options.extension } : {},
+    ...options.middleware ? { middleware: options.middleware } : {}
+  });
+  return {
+    ...plugin,
+    functions: options.functions ?? {}
+  };
+};
+const mergeSchemaExtension = (base, extension) => {
+  const { key } = extension;
+  const bareNames = new Set(Object.keys(extension.tables));
+  const merged = { ...base.tables };
+  for (const [bareName, table] of Object.entries(extension.tables)) {
+    const prefixed = prefixTableName(key, bareName);
+    if (Object.hasOwn(merged, prefixed)) {
+      throw new Error(
+        `defineSchema(...).extend("${key}"): table "${prefixed}" already exists in the base schema — another extension with the same key already contributed it`
+      );
+    }
+    merged[prefixed] = rewriteTableReferences(table, key, bareNames, bareName);
+  }
+  const mergedVectorIndexes = { ...base.vectorIndexes };
+  if (extension.vectorIndexes) {
+    for (const [bareIndexName, index] of Object.entries(extension.vectorIndexes)) {
+      const prefixed = prefixTableName(key, bareIndexName);
+      if (Object.hasOwn(mergedVectorIndexes, prefixed)) {
+        throw new Error(
+          `defineSchema(...).extend("${key}"): vector index "${prefixed}" already exists in the base schema — another extension with the same key already contributed it`
+        );
+      }
+      mergedVectorIndexes[prefixed] = { ...index, table: rewriteReference(index.table, key, bareNames) };
+    }
+  }
+  return {
+    // Preserve secure-by-default RLS across `.extend(...)` — a plugin's
+    // tables join an `.rls("required")` schema as protected-by-default too.
+    rlsMode: base.rlsMode,
+    tables: merged,
+    vectorIndexes: mergedVectorIndexes
+  };
+};
+const installPlugins = (base, plugins) => {
+  let schema = base;
+  for (const plugin of plugins) {
+    if (plugin.extension) {
+      schema = mergeSchemaExtension(schema, plugin.extension);
+    }
+  }
+  return schema;
+};
+const composePluginMiddleware = (plugins) => {
+  const middlewares = plugins.map((plugin) => plugin.middleware).filter((middleware) => middleware !== void 0);
+  return (async ({ ctx, next }) => runMiddlewareChain(middlewares, ctx, (context) => next({ ctx: context })));
+};
+
+export { composePluginMiddleware, defineComponent, definePlugin, defineSchemaExtension, installPlugins, mergeSchemaExtension };

package/dist/packem_shared/defineStorageRule-qu0mpilX.mjs

@@ -0,0 +1,20 @@
+const defineStorageRule = (input) => {
+  return { bucket: input.bucket, on: input.on, prefix: input.prefix, when: input.when };
+};
+const defineStorageRules = (rules) => {
+  const seenWhenByKey = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    const key = JSON.stringify([rule.bucket, rule.on, rule.prefix]);
+    const whens = seenWhenByKey.get(key) ?? /* @__PURE__ */ new Set();
+    if (whens.has(rule.when)) {
+      throw new Error(
+        `defineStorageRules: duplicate rule for (bucket "${rule.bucket}", on "${rule.on}"${rule.prefix === void 0 ? "" : `, prefix "${rule.prefix}"`}) — the same decision function is registered more than once. Multiple distinct rules per (bucket, on) are allowed (they OR); remove the duplicate.`
+      );
+    }
+    whens.add(rule.when);
+    seenWhenByKey.set(key, whens);
+  }
+  return rules;
+};
+
+export { defineStorageRule, defineStorageRules };

package/dist/packem_shared/httpAction-B7FYUEgr.mjs

@@ -0,0 +1,340 @@
+import { parseValidatorMap, ValidationError } from '@lunora/values';
+import { Hono } from 'hono';
+import { LunoraError } from './LunoraError-DhggBJZF.mjs';
+
+const httpAction = (handler) => async (c) => handler(c.get("lunora"), c.req.raw);
+const httpRouter = () => {
+  const app = new Hono();
+  app.use("*", async (c, next) => {
+    const injected = c.env.__lunoraCtx;
+    if (!injected) {
+      throw new LunoraError(
+        "INTERNAL_SERVER_ERROR",
+        "HttpActionCtx was not injected — mount httpRouter() on createWorker(), which supplies it per request."
+      );
+    }
+    c.set("lunora", injected);
+    await next();
+  });
+  return app;
+};
+const unwrapOptional = (validator) => validator.kind === "optional" ? validator._meta?.inner ?? validator : validator;
+const coerceScalar = (kind, raw) => {
+  switch (kind) {
+    case "bigint": {
+      try {
+        return BigInt(raw);
+      } catch {
+        return raw;
+      }
+    }
+    case "boolean": {
+      if (raw === "true" || raw === "1") {
+        return true;
+      }
+      if (raw === "false" || raw === "0") {
+        return false;
+      }
+      return raw;
+    }
+    case "number": {
+      return raw === "" ? Number.NaN : Number(raw);
+    }
+    default: {
+      return raw;
+    }
+  }
+};
+const coerceSearchParameter = (validator, c, key) => {
+  const effective = unwrapOptional(validator);
+  if (effective.kind === "array") {
+    const values = c.req.queries(key);
+    if (values === void 0) {
+      return void 0;
+    }
+    const element = effective._meta?.inner;
+    return values.map((raw2) => coerceScalar(element?.kind ?? "string", raw2));
+  }
+  const raw = c.req.query(key);
+  return raw === void 0 ? void 0 : coerceScalar(effective.kind, raw);
+};
+const parseSearchParams = (validators, c) => {
+  const raw = {};
+  for (const key of Object.keys(validators)) {
+    const validator = validators[key];
+    if (!validator) {
+      continue;
+    }
+    raw[key] = coerceSearchParameter(validator, c, key);
+  }
+  return parseValidatorMap(validators, raw, "searchParams");
+};
+const parseParams = (validators, c) => {
+  const provided = c.req.param();
+  const raw = {};
+  for (const key of Object.keys(validators)) {
+    const validator = validators[key];
+    if (!validator) {
+      continue;
+    }
+    const value = provided[key];
+    raw[key] = value === void 0 ? void 0 : coerceScalar(unwrapOptional(validator).kind, value);
+  }
+  return parseValidatorMap(validators, raw, "params");
+};
+const parseBody = async (validators, c) => {
+  let json;
+  try {
+    json = await c.req.json();
+  } catch {
+    throw new LunoraError("BAD_REQUEST", "Invalid JSON body");
+  }
+  if (typeof json !== "object" || json === null || Array.isArray(json)) {
+    throw new LunoraError("BAD_REQUEST", "Expected a JSON object body");
+  }
+  return parseValidatorMap(validators, json, "body");
+};
+const applyOutput = (output, result) => {
+  try {
+    return output.parse(result);
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      throw new LunoraError("INTERNAL_SERVER_ERROR", `Response did not match the declared output schema: ${error.message}`);
+    }
+    throw error;
+  }
+};
+const errorResponse = (error) => {
+  if (error instanceof ValidationError) {
+    return Response.json({ code: "BAD_REQUEST", error: error.message }, { status: 400 });
+  }
+  if (error instanceof LunoraError) {
+    return Response.json({ code: error.code, error: error.message }, { status: error.status });
+  }
+  throw error;
+};
+const buildRouteHandler = (state, userHandler) => async (c) => {
+  try {
+    const context = c.get("lunora");
+    const searchParams = Object.keys(state.searchParams).length > 0 ? parseSearchParams(state.searchParams, c) : {};
+    const params = Object.keys(state.params).length > 0 ? parseParams(state.params, c) : {};
+    const body = Object.keys(state.body).length > 0 ? await parseBody(state.body, c) : {};
+    const result = await userHandler({ body, ctx: context, params, searchParams });
+    const payload = state.output ? applyOutput(state.output, result) : result;
+    return payload === void 0 ? new Response(null, { status: 204 }) : Response.json(payload);
+  } catch (error) {
+    return errorResponse(error);
+  }
+};
+const isLunoraErrorLike = (error) => {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const candidate = error;
+  return candidate.name === "LunoraError" && typeof candidate.code === "string" && typeof candidate.message === "string";
+};
+const sseFrame = (chunk, event) => {
+  const data = JSON.stringify(chunk);
+  const prefix = event ? `event: ${event}
+` : "";
+  return `${prefix}data: ${data}
+
+`;
+};
+const buildStreamHandler = (state, userHandler) => (
+  // eslint-disable-next-line @typescript-eslint/require-await -- LunoraRouteHandler is contractually `(c) => Promise<Response>`; this handler returns synchronously (all awaits live inside the ReadableStream pump), so `async` is required by the type, not the body.
+  async (c) => {
+    let searchParams;
+    let params;
+    try {
+      searchParams = Object.keys(state.searchParams).length > 0 ? parseSearchParams(state.searchParams, c) : {};
+      params = Object.keys(state.params).length > 0 ? parseParams(state.params, c) : {};
+    } catch (error) {
+      return errorResponse(error);
+    }
+    const context = c.get("lunora");
+    const request = c.req.raw;
+    const encoder = new TextEncoder();
+    const ac = new AbortController();
+    if (request.signal.aborted) {
+      ac.abort();
+      return new Response(
+        new ReadableStream({
+          start: (controller) => {
+            controller.close();
+          }
+        }),
+        {
+          headers: {
+            "cache-control": "no-cache, no-transform",
+            "content-type": "text/event-stream; charset=utf-8",
+            "x-accel-buffering": "no"
+          }
+        }
+      );
+    }
+    const onAbort = () => {
+      ac.abort();
+    };
+    request.signal.addEventListener("abort", onAbort, { once: true });
+    const stream = new ReadableStream({
+      cancel() {
+        request.signal.removeEventListener("abort", onAbort);
+        ac.abort();
+      },
+      async start(controller) {
+        try {
+          const iterator = userHandler({ ctx: context, params, request, searchParams, signal: ac.signal });
+          for await (const chunk of iterator) {
+            if (ac.signal.aborted) {
+              break;
+            }
+            controller.enqueue(encoder.encode(sseFrame(chunk)));
+          }
+          controller.enqueue(encoder.encode(sseFrame({}, "complete")));
+        } catch (error) {
+          let payload;
+          if (isLunoraErrorLike(error)) {
+            payload = { code: error.code, message: error.message };
+          } else {
+            console.error("[lunora] unhandled stream handler error:", error);
+            payload = { code: "INTERNAL_SERVER_ERROR", message: "Internal error" };
+          }
+          controller.enqueue(encoder.encode(sseFrame(payload, "error")));
+        } finally {
+          request.signal.removeEventListener("abort", onAbort);
+          controller.close();
+        }
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "cache-control": "no-cache, no-transform",
+        "content-type": "text/event-stream; charset=utf-8",
+        // Hint to proxies (including Cloudflare's own buffering layer)
+        // that this response must not be coalesced.
+        "x-accel-buffering": "no"
+      }
+    });
+  }
+);
+const makeRouteBuilder = (state) => {
+  return {
+    body: (validators) => makeRouteBuilder({ ...state, body: { ...state.body, ...validators } }),
+    handler: (userHandler) => buildRouteHandler(state, userHandler),
+    output: (validator) => makeRouteBuilder({ ...state, output: validator }),
+    params: (validators) => makeRouteBuilder({ ...state, params: { ...state.params, ...validators } }),
+    searchParams: (validators) => makeRouteBuilder({ ...state, searchParams: { ...state.searchParams, ...validators } }),
+    stream: (userHandler) => buildStreamHandler(state, userHandler)
+  };
+};
+const makeRouteFactory = (method) => (path) => makeRouteBuilder({ body: {}, method, params: {}, path, searchParams: {} });
+const httpRoute = {
+  delete: makeRouteFactory("DELETE"),
+  get: makeRouteFactory("GET"),
+  head: makeRouteFactory("HEAD"),
+  options: makeRouteFactory("OPTIONS"),
+  patch: makeRouteFactory("PATCH"),
+  post: makeRouteFactory("POST"),
+  put: makeRouteFactory("PUT")
+};
+const SINGLE_BYTE_RANGE_RE = /^bytes=(\d*)-(\d*)$/;
+const toHttpEtag = (etag) => {
+  if (etag.startsWith('"') || etag.startsWith('W/"')) {
+    return etag;
+  }
+  return `"${etag}"`;
+};
+const isSafeHeaderValue = (value) => {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.codePointAt(index);
+    if (code === 13 || code === 10 || code === 0) {
+      return false;
+    }
+  }
+  return true;
+};
+const parseRange = (header, size) => {
+  if (header === null) {
+    return { kind: "full" };
+  }
+  const match = SINGLE_BYTE_RANGE_RE.exec(header.trim());
+  if (!match) {
+    return { kind: "full" };
+  }
+  const startRaw = match[1] ?? "";
+  const endRaw = match[2] ?? "";
+  if (startRaw === "" && endRaw === "") {
+    return { kind: "full" };
+  }
+  let start;
+  let end;
+  if (startRaw === "") {
+    const suffix = Number(endRaw);
+    if (suffix === 0) {
+      return { kind: "unsatisfiable" };
+    }
+    start = Math.max(0, size - suffix);
+    end = size - 1;
+  } else {
+    start = Number(startRaw);
+    end = endRaw === "" ? size - 1 : Math.min(Number(endRaw), size - 1);
+  }
+  if (start > end || start >= size) {
+    return { kind: "unsatisfiable" };
+  }
+  return { end, kind: "partial", start };
+};
+const serveStorageObject = async (context, key, request) => {
+  const object = await context.storage.download(key);
+  if (!object) {
+    return new Response("Not Found", { status: 404 });
+  }
+  const rawContentType = object.httpMetadata?.contentType;
+  const contentType = rawContentType !== void 0 && isSafeHeaderValue(rawContentType) ? rawContentType : "application/octet-stream";
+  const baseHeaders = {
+    "accept-ranges": "bytes",
+    "content-type": contentType,
+    etag: toHttpEtag(object.etag)
+  };
+  if (object.sha256Base64 !== void 0) {
+    baseHeaders["repr-digest"] = `sha-256=:${object.sha256Base64}:`;
+  }
+  const range = parseRange(request.headers.get("range"), object.size);
+  if (range.kind === "unsatisfiable") {
+    object.body?.cancel().catch(() => {
+    });
+    return new Response("Range Not Satisfiable", {
+      headers: {
+        "accept-ranges": "bytes",
+        "content-range": `bytes */${String(object.size)}`,
+        "content-type": "text/plain; charset=utf-8",
+        etag: toHttpEtag(object.etag)
+      },
+      status: 416
+    });
+  }
+  if (range.kind === "full") {
+    return new Response(object.body, {
+      headers: { ...baseHeaders, "content-length": String(object.size) },
+      status: 200
+    });
+  }
+  object.body?.cancel().catch(() => {
+  });
+  const length = range.end - range.start + 1;
+  const slice = await context.storage.download(key, { range: { length, offset: range.start } });
+  if (!slice) {
+    return new Response("Not Found", { status: 404 });
+  }
+  return new Response(slice.body, {
+    headers: {
+      ...baseHeaders,
+      "content-length": String(length),
+      "content-range": `bytes ${String(range.start)}-${String(range.end)}/${String(object.size)}`
+    },
+    status: 206
+  });
+};
+
+export { httpAction, httpRoute, httpRouter, serveStorageObject };

package/dist/packem_shared/initLunora-CATvPsVt.mjs

@@ -0,0 +1,86 @@
+import { parseValidatorMap } from '@lunora/values';
+import { r as runMiddlewareChain } from './run-middleware-CYQOuoV6.mjs';
+
+const validateArgs = (validators, args) => parseValidatorMap(validators, args, "args");
+
+const runMiddleware = (middlewares, baseContext) => runMiddlewareChain(middlewares, baseContext, (context) => context);
+const makeHandler = (args, middlewares, userHandler, output) => async (context, rawArgs) => {
+  const parsed = validateArgs(args, rawArgs);
+  const resolvedContext = await runMiddleware(middlewares, context);
+  const result = await userHandler({ args: parsed, ctx: resolvedContext });
+  return output ? output.parse(result) : result;
+};
+const makeStreamHandler = (args, middlewares, userHandler) => (context, rawArgs, signal) => {
+  const parsed = validateArgs(args, rawArgs);
+  return (async function* drive() {
+    const resolvedContext = await runMiddleware(middlewares, context);
+    const source = userHandler({ args: parsed, ctx: resolvedContext, signal });
+    const iterator = source[Symbol.asyncIterator]();
+    try {
+      while (true) {
+        if (signal.aborted) {
+          return;
+        }
+        const next = await iterator.next();
+        if (next.done) {
+          return;
+        }
+        if (signal.aborted) {
+          return;
+        }
+        yield next.value;
+      }
+    } finally {
+      await iterator.return?.();
+    }
+  })();
+};
+const makeBuilder = (kind, state, visibility) => {
+  return {
+    __lunoraProcedure: kind,
+    ...visibility ? { __lunoraVisibility: visibility } : {},
+    input: (validators) => makeBuilder(kind, { ...state, args: { ...state.args, ...validators } }, visibility),
+    [kind]: (userHandler) => {
+      return {
+        args: state.args,
+        handler: makeHandler(state.args, state.middlewares, userHandler, state.output),
+        kind,
+        ...visibility ? { visibility } : {}
+      };
+    },
+    output: (validator) => makeBuilder(kind, { ...state, output: validator }, visibility),
+    // `.stream()` is meaningful only on query builders. It's harmless to expose
+    // on every builder shape (callers can't hit it from action/mutation builders
+    // anyway since the type system narrows it away), but emitting it
+    // unconditionally keeps the runtime free of per-kind branching.
+    ...kind === "query" ? {
+      stream: (userHandler) => {
+        return {
+          args: state.args,
+          handler: makeStreamHandler(state.args, state.middlewares, userHandler),
+          kind: "stream",
+          ...visibility ? { visibility } : {}
+        };
+      }
+    } : {},
+    use: (middleware) => makeBuilder(kind, { ...state, middlewares: [...state.middlewares, middleware] }, visibility)
+  };
+};
+const initLunora = {
+  dataModel: () => {
+    return {
+      create: (_options) => {
+        return {
+          action: makeBuilder("action", { args: {}, middlewares: [] }),
+          internalAction: makeBuilder("action", { args: {}, middlewares: [] }, "internal"),
+          internalMutation: makeBuilder("mutation", { args: {}, middlewares: [] }, "internal"),
+          internalQuery: makeBuilder("query", { args: {}, middlewares: [] }, "internal"),
+          mutation: makeBuilder("mutation", { args: {}, middlewares: [] }),
+          query: makeBuilder("query", { args: {}, middlewares: [] })
+        };
+      }
+    };
+  }
+};
+
+export { initLunora };