@lunora/server 1.0.0-alpha.31 → 1.0.0-alpha.32

package/dist/rls/testing.mjs

@@ -1,49 +1 @@
-import { indexRolePermissions, computeReadBaseWhere, matchesWhere, evaluateWrite, permissionName } from '../packem_shared/rls-BaDQf7MG.mjs';
-
-const expectPolicy = (policies, options = {}) => {
-  const rolePermissions = indexRolePermissions(options.roles);
-  const context = options.ctx ?? {};
-  return {
-    as: (identity) => {
-      const auth = identity ?? {};
-      const roles = auth.roles ?? [];
-      const granted = /* @__PURE__ */ new Set();
-      for (const roleName of roles) {
-        for (const name of rolePermissions.get(roleName) ?? []) {
-          granted.add(name);
-        }
-      }
-      const baseContext = {
-        auth: {
-          can: (permission) => granted.has(permissionName(permission)),
-          // eslint-disable-next-line unicorn/no-null -- PolicyContext.auth.identity is a public `… | null` type, mirroring the middleware
-          identity: auth.identity ?? null,
-          roles,
-          // eslint-disable-next-line unicorn/no-null -- PolicyContext.auth.userId is a public `null | string` type, mirroring the middleware
-          userId: auth.userId ?? null
-        },
-        ctx: context
-      };
-      const can = (op, table, row, nextRow) => {
-        const tablePolicies = policies.filter((policy) => policy.table === table);
-        if (tablePolicies.length === 0) {
-          return true;
-        }
-        if (op === "read") {
-          if (!tablePolicies.some((policy) => policy.on === "read")) {
-            return true;
-          }
-          const baseWhere = computeReadBaseWhere(tablePolicies, baseContext);
-          return baseWhere === void 0 || matchesWhere(row ?? {}, baseWhere);
-        }
-        return evaluateWrite(tablePolicies, op, { ...baseContext, row }, nextRow);
-      };
-      return {
-        can,
-        cannot: (op, table, row, nextRow) => !can(op, table, row, nextRow)
-      };
-    }
-  };
-};
-
-export { expectPolicy };
+import{indexRolePermissions as y,computeReadBaseWhere as I,matchesWhere as P,evaluateWrite as W,permissionName as g}from"../packem_shared/rls-_iVsPvhX.mjs";const w=(f,i={})=>{const m=y(i.roles),h=i.ctx??{};return{as:p=>{const s=p??{},c=s.roles??[],u=new Set;for(const e of c)for(const t of m.get(e)??[])u.add(t);const l={auth:{can:e=>u.has(g(e)),identity:s.identity??null,roles:c,userId:s.userId??null},ctx:h},d=(e,t,r,a)=>{const n=f.filter(o=>o.table===t);if(n.length===0)return!0;if(e==="read"){if(!n.some(x=>x.on==="read"))return!0;const o=I(n,l);return o===void 0||P(r??{},o)}return W(n,e,{...l,row:r},a)};return{can:d,cannot:(e,t,r,a)=>!d(e,t,r,a)}}}};export{w as expectPolicy};

package/dist/types.d.mts

@@ -282,6 +282,17 @@ interface TableDefinition<Shape extends Record<string, Validator> = Record<strin
    * Has no effect when the schema does not require RLS.
    */
   isPublic?: boolean;
+  /**
+   * Set by `.ownedBy(field)` — the column holding the owning user's id (named
+   * `ownerField`, a data field, rather than colliding with the fluent
+   * `.ownedBy()` builder method — same convention as `shardBy()`/`shardMode`).
+   *
+   * A shape over this table with `owner: true` derives its predicate from this
+   * field, so "only the owner may replicate these rows" is declared once on the
+   * table instead of being restated in every shape's `where`. Absent ⇒ the table
+   * has no single owning column and a shape must spell its predicate out.
+   */
+  ownerField?: string;
   /**
    * Rank indexes declared via `.rankIndex(name, opts)`. The runtime maintains
    * a sorted companion table per declared rank with a btree on
@@ -532,6 +543,30 @@ interface SystemDatabaseReader {
  * actual SQL implementation lives in `@lunora/do`; these are signatures only.
  */
 interface DatabaseReader {
+  /**
+   * The throwing sibling of {@link DatabaseReader.normalizeId}: brand `id` as an
+   * {@link Id} for `tableName`, or throw `BAD_REQUEST` when it is not structurally
+   * an id. Pure — it never reads the database, so a valid id for a row that
+   * doesn't exist still returns.
+   *
+   * This is the **parse boundary** for an id that arrived as a plain `string`: a
+   * wire payload, a mutator's args, a change plan computed on the client. The
+   * alternative is `value as Id&lt;"table">` at every such call site — an assertion,
+   * not a check, and one that has to be repeated for every table a helper is
+   * generic over:
+   *
+   * ```ts
+   * for (const patch of plan.patches) {
+   *     await ctx.db.patch(ctx.db.asId("nodes", patch.id), patch.fields);
+   * }
+   * ```
+   *
+   * Ids are opaque strings, so the check is exactly `normalizeId`'s: it rejects
+   * empty, whitespace-bearing, and NUL-bearing values, not "an id that isn't in
+   * this table". Use it to get the brand honestly, and `get()` to learn whether
+   * the row exists.
+   */
+  asId: <T extends string>(tableName: T, id: string) => Id<T>;
   get: <T extends string>(id: Id<T>) => Promise<Record<string, unknown> | null>;
   /**
    * Validate an untrusted `id` string against the structural shape of an id
@@ -686,6 +721,24 @@ interface InsertManyOptions extends BatchWriteOptions {
 }
 interface DatabaseWriter extends DatabaseReader {
   delete: <T extends string>(id: Id<T>) => Promise<void>;
+  /**
+   * Delete EVERY row in `tableName`, chunking internally until the table is
+   * empty — the erasure primitive.
+   *
+   * Unlike `deleteWhere(tableName, {})` there is **no batch cap**: a
+   * `BATCH_LIMIT_EXCEEDED` at row 501 of an account deletion is a bug, not a
+   * safety rail. Rows still go through the single-row delete pipeline, so
+   * triggers, cascades, companions, CDC, and live subscriptions stay correct.
+   *
+   * On a `.softDelete()` table the default flips the marker column; pass
+   * `{ hard: true }` to remove the rows physically (what GDPR erasure means).
+   */
+  deleteAll: (tableName: string, options?: {
+    chunkSize?: number;
+    hard?: boolean;
+  }) => Promise<{
+    deleted: number;
+  }>;
   /**
    * Delete many rows by id in one call. Each id is deleted through the full
    * single-row pipeline (triggers + per-row RLS). The returned `deleted` is the
@@ -793,6 +846,29 @@ interface DatabaseWriter extends DatabaseReader {
     patched: number;
   }>;
   replace: <T extends string>(id: Id<T>, document: Record<string, unknown>) => Promise<void>;
+  /**
+   * Erase every shard-local table — the account-deletion / tenant-teardown
+   * primitive. Sweeps the schema's non-`.global()` tables with
+   * {@link DatabaseWriter.deleteAll}`({ hard: true })` and returns the per-table
+   * counts.
+   *
+   * `.global()` tables are skipped by design: their rows live in D1 and are shared
+   * across shards, so "wipe this shard" must not reach them. Restrict the sweep
+   * with `options.tables`, or spare one with `options.exclude` (e.g. an audit log
+   * that must outlive the data).
+   *
+   * ```ts
+   * export const deleteAccount = internalMutation({ handler: async ({ ctx }) => ctx.db.wipeShard() });
+   * ```
+   */
+  wipeShard: (options?: {
+    chunkSize?: number;
+    exclude?: ReadonlyArray<string>;
+    tables?: ReadonlyArray<string>;
+  }) => Promise<{
+    deleted: number;
+    tables: Record<string, number>;
+  }>;
 }
 /** Authenticated identity surfaced into every context. */
 interface AuthState {

package/dist/types.d.ts

@@ -282,6 +282,17 @@ interface TableDefinition<Shape extends Record<string, Validator> = Record<strin
    * Has no effect when the schema does not require RLS.
    */
   isPublic?: boolean;
+  /**
+   * Set by `.ownedBy(field)` — the column holding the owning user's id (named
+   * `ownerField`, a data field, rather than colliding with the fluent
+   * `.ownedBy()` builder method — same convention as `shardBy()`/`shardMode`).
+   *
+   * A shape over this table with `owner: true` derives its predicate from this
+   * field, so "only the owner may replicate these rows" is declared once on the
+   * table instead of being restated in every shape's `where`. Absent ⇒ the table
+   * has no single owning column and a shape must spell its predicate out.
+   */
+  ownerField?: string;
   /**
    * Rank indexes declared via `.rankIndex(name, opts)`. The runtime maintains
    * a sorted companion table per declared rank with a btree on
@@ -532,6 +543,30 @@ interface SystemDatabaseReader {
  * actual SQL implementation lives in `@lunora/do`; these are signatures only.
  */
 interface DatabaseReader {
+  /**
+   * The throwing sibling of {@link DatabaseReader.normalizeId}: brand `id` as an
+   * {@link Id} for `tableName`, or throw `BAD_REQUEST` when it is not structurally
+   * an id. Pure — it never reads the database, so a valid id for a row that
+   * doesn't exist still returns.
+   *
+   * This is the **parse boundary** for an id that arrived as a plain `string`: a
+   * wire payload, a mutator's args, a change plan computed on the client. The
+   * alternative is `value as Id&lt;"table">` at every such call site — an assertion,
+   * not a check, and one that has to be repeated for every table a helper is
+   * generic over:
+   *
+   * ```ts
+   * for (const patch of plan.patches) {
+   *     await ctx.db.patch(ctx.db.asId("nodes", patch.id), patch.fields);
+   * }
+   * ```
+   *
+   * Ids are opaque strings, so the check is exactly `normalizeId`'s: it rejects
+   * empty, whitespace-bearing, and NUL-bearing values, not "an id that isn't in
+   * this table". Use it to get the brand honestly, and `get()` to learn whether
+   * the row exists.
+   */
+  asId: <T extends string>(tableName: T, id: string) => Id<T>;
   get: <T extends string>(id: Id<T>) => Promise<Record<string, unknown> | null>;
   /**
    * Validate an untrusted `id` string against the structural shape of an id
@@ -686,6 +721,24 @@ interface InsertManyOptions extends BatchWriteOptions {
 }
 interface DatabaseWriter extends DatabaseReader {
   delete: <T extends string>(id: Id<T>) => Promise<void>;
+  /**
+   * Delete EVERY row in `tableName`, chunking internally until the table is
+   * empty — the erasure primitive.
+   *
+   * Unlike `deleteWhere(tableName, {})` there is **no batch cap**: a
+   * `BATCH_LIMIT_EXCEEDED` at row 501 of an account deletion is a bug, not a
+   * safety rail. Rows still go through the single-row delete pipeline, so
+   * triggers, cascades, companions, CDC, and live subscriptions stay correct.
+   *
+   * On a `.softDelete()` table the default flips the marker column; pass
+   * `{ hard: true }` to remove the rows physically (what GDPR erasure means).
+   */
+  deleteAll: (tableName: string, options?: {
+    chunkSize?: number;
+    hard?: boolean;
+  }) => Promise<{
+    deleted: number;
+  }>;
   /**
    * Delete many rows by id in one call. Each id is deleted through the full
    * single-row pipeline (triggers + per-row RLS). The returned `deleted` is the
@@ -793,6 +846,29 @@ interface DatabaseWriter extends DatabaseReader {
     patched: number;
   }>;
   replace: <T extends string>(id: Id<T>, document: Record<string, unknown>) => Promise<void>;
+  /**
+   * Erase every shard-local table — the account-deletion / tenant-teardown
+   * primitive. Sweeps the schema's non-`.global()` tables with
+   * {@link DatabaseWriter.deleteAll}`({ hard: true })` and returns the per-table
+   * counts.
+   *
+   * `.global()` tables are skipped by design: their rows live in D1 and are shared
+   * across shards, so "wipe this shard" must not reach them. Restrict the sweep
+   * with `options.tables`, or spare one with `options.exclude` (e.g. an audit log
+   * that must outlive the data).
+   *
+   * ```ts
+   * export const deleteAccount = internalMutation({ handler: async ({ ctx }) => ctx.db.wipeShard() });
+   * ```
+   */
+  wipeShard: (options?: {
+    chunkSize?: number;
+    exclude?: ReadonlyArray<string>;
+    tables?: ReadonlyArray<string>;
+  }) => Promise<{
+    deleted: number;
+    tables: Record<string, number>;
+  }>;
 }
 /** Authenticated identity surfaced into every context. */
 interface AuthState {

package/dist/types.mjs

@@ -1,31 +1 @@
-const namespaceCache = /* @__PURE__ */ new Map();
-const anyApi = /* @__PURE__ */ new Proxy(
-  {},
-  {
-    get(_target, namespace) {
-      const cached = namespaceCache.get(namespace);
-      if (cached) {
-        return cached;
-      }
-      const refCache = /* @__PURE__ */ new Map();
-      const nsProxy = /* @__PURE__ */ new Proxy(
-        {},
-        {
-          get(_inner, functionName) {
-            const cachedRef = refCache.get(functionName);
-            if (cachedRef) {
-              return cachedRef;
-            }
-            const ref = { __lunoraRef: `${String(namespace)}:${String(functionName)}` };
-            refCache.set(functionName, ref);
-            return ref;
-          }
-        }
-      );
-      namespaceCache.set(namespace, nsProxy);
-      return nsProxy;
-    }
-  }
-);
-
-export { anyApi };
+const a=new Map,u=new Proxy({},{get(i,t){const e=a.get(t);if(e)return e;const r=new Map,o=new Proxy({},{get(c,n){const s=r.get(n);if(s)return s;const g={__lunoraRef:`${String(t)}:${String(n)}`};return r.set(n,g),g}});return a.set(t,o),o}});export{u as anyApi};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/server",
-  "version": "1.0.0-alpha.31",
+  "version": "1.0.0-alpha.32",
   "description": "Server primitives for Lunora: defineSchema, defineTable, query, mutation, and action",
   "keywords": [
     "backend",

package/dist/packem_shared/LunoraEnvError-BGmd1Qs0.mjs

@@ -1,187 +0,0 @@
-import { LunoraError as LunoraError$1 } from '@lunora/errors';
-import { optionalInner } from '@lunora/values';
-
-const SECRET_VALUE_PREFIXES = [
-  /^sk_/u,
-  /^pk_/u,
-  /^rk_/u,
-  /^ghp_/u,
-  /^gho_/u,
-  /^ghs_/u,
-  /^ghr_/u,
-  /^github_pat_/u,
-  /^xox[baprs]-/u,
-  /^AKIA/u,
-  /^AIza/u,
-  /^Bearer\s/u
-];
-const HIGH_ENTROPY_TOKEN = /[\w./+-]{24,}/gu;
-const STANDALONE_TOKEN = /^[\w./+-]+$/u;
-const EMBEDDED_PREFIXED_TOKEN_SHORT = /\b(?:(?:sk|pk|rk|ghp|gho|ghs|ghr)_[\w./+-]*|github_pat_[\w./+-]*|xox[baprs]-[\w./+-]*)/gu;
-const EMBEDDED_PREFIXED_TOKEN_LONG = /\b(?:AKIA|AIza)[\w./+-]+|Bearer\s+[\w./+-]+/gu;
-const URL_CREDENTIAL = /\b([a-z][\w.+-]*:\/\/[\w.%+-]+):[\w.%+-]+@/gu;
-const REDACTED = "[redacted]";
-const SECRET_KEY = /(?:KEY|PASSWORD|SECRET|TOKEN)$/u;
-const looksLikeSecretValue = (value) => {
-  if (SECRET_VALUE_PREFIXES.some((prefix) => prefix.test(value))) {
-    return true;
-  }
-  const trimmed = value.trim();
-  return trimmed.length >= 24 && STANDALONE_TOKEN.test(trimmed);
-};
-const QUOTED_VALUE = /(["'])(?<inner>(?:\\.|(?!\1).)*)\1/gu;
-const KEYED_VALUE = /\b(?<key>[A-Za-z_]\w*)\s*[=:]\s*\S+/gu;
-const redactSecrets = (message) => {
-  let out = message;
-  out = out.replaceAll(QUOTED_VALUE, (match, ...groups) => {
-    const named = groups.at(-1);
-    return named?.inner !== void 0 && looksLikeSecretValue(named.inner) ? REDACTED : match;
-  });
-  out = out.replaceAll(URL_CREDENTIAL, (_match, prefix) => `${prefix}:${REDACTED}@`);
-  out = out.replaceAll(EMBEDDED_PREFIXED_TOKEN_SHORT, REDACTED);
-  out = out.replaceAll(EMBEDDED_PREFIXED_TOKEN_LONG, REDACTED);
-  out = out.replaceAll(KEYED_VALUE, (match, ...groups) => {
-    const named = groups.at(-1);
-    return named?.key !== void 0 && SECRET_KEY.test(named.key) ? `${named.key}=${REDACTED}` : match;
-  });
-  out = out.replaceAll(HIGH_ENTROPY_TOKEN, REDACTED);
-  return out;
-};
-const redactValueForKey = (message, key, raw) => {
-  const masked = redactSecrets(message);
-  if (typeof raw === "string" && raw !== "" && SECRET_KEY.test(key)) {
-    return masked.replaceAll(raw, REDACTED);
-  }
-  return masked;
-};
-class LunoraEnvError extends LunoraError$1 {
-  failures;
-  constructor(failures) {
-    const summary = failures.map((failure) => `  - ${failure.key}: ${failure.message}`).join("\n");
-    super("ENV_INVALID", `Invalid environment (${String(failures.length)} key(s)):
-${summary}`, { name: "LunoraEnvError" });
-    this.failures = failures;
-  }
-}
-const TRUE_VALUES = /* @__PURE__ */ new Set(["1", "on", "true", "yes"]);
-const FALSE_VALUES = /* @__PURE__ */ new Set(["0", "false", "no", "off"]);
-const INTEGER_LITERAL = /^-?\d+$/u;
-const unwrapKind = (validator) => {
-  if (validator.kind !== "optional") {
-    return validator.kind;
-  }
-  const inner = optionalInner(validator);
-  return inner ? unwrapKind(inner) : validator.kind;
-};
-const coerce = (validator, raw) => {
-  if (typeof raw !== "string") {
-    return raw;
-  }
-  switch (unwrapKind(validator)) {
-    case "bigint": {
-      return INTEGER_LITERAL.test(raw.trim()) ? BigInt(raw.trim()) : raw;
-    }
-    case "boolean": {
-      const lowered = raw.trim().toLowerCase();
-      if (TRUE_VALUES.has(lowered)) {
-        return true;
-      }
-      if (FALSE_VALUES.has(lowered)) {
-        return false;
-      }
-      return raw;
-    }
-    case "number": {
-      const trimmed = raw.trim();
-      if (trimmed === "") {
-        return raw;
-      }
-      const parsed = Number(trimmed);
-      return Number.isNaN(parsed) ? raw : parsed;
-    }
-    default: {
-      return raw;
-    }
-  }
-};
-const validateKey = (key, validator, env, failures) => {
-  const raw = env[key];
-  if (raw === void 0 && validator.kind === "optional") {
-    return { ok: true, value: void 0 };
-  }
-  const result = validator.safeParse(coerce(validator, raw));
-  if (result.ok) {
-    return { ok: true, value: result.value };
-  }
-  failures.push({ key, message: redactValueForKey(result.error.message, key, raw) });
-  return { ok: false };
-};
-const requireEnvObject = (env) => {
-  if (typeof env !== "object" || env === null) {
-    throw new LunoraEnvError([{ key: "<env>", message: `expected an object, received ${env === null ? "null" : typeof env}` }]);
-  }
-  return env;
-};
-const defineEnv = (shape) => {
-  const keys = Object.keys(shape);
-  const cache = /* @__PURE__ */ new WeakMap();
-  const accessor = ((env) => {
-    const source = requireEnvObject(env);
-    let resolved = cache.get(source);
-    if (resolved === void 0) {
-      resolved = /* @__PURE__ */ new Map();
-      cache.set(source, resolved);
-    }
-    const cached = resolved;
-    const read = (property) => {
-      if (cached.has(property)) {
-        return cached.get(property);
-      }
-      const failures = [];
-      const outcome = validateKey(property, shape[property], source, failures);
-      if (!outcome.ok) {
-        throw new LunoraEnvError(failures);
-      }
-      cached.set(property, outcome.value);
-      return outcome.value;
-    };
-    return /* @__PURE__ */ new Proxy({}, {
-      get(_target, property) {
-        if (typeof property !== "string" || !(property in shape)) {
-          return void 0;
-        }
-        return read(property);
-      },
-      getOwnPropertyDescriptor(_target, property) {
-        if (typeof property === "string" && property in shape) {
-          return { configurable: true, enumerable: true, value: read(property), writable: false };
-        }
-        return void 0;
-      },
-      has(_target, property) {
-        return typeof property === "string" && property in shape;
-      },
-      ownKeys() {
-        return keys;
-      }
-    });
-  });
-  accessor.parse = (env) => {
-    const source = requireEnvObject(env);
-    const failures = [];
-    const out = {};
-    for (const key of keys) {
-      const outcome = validateKey(key, shape[key], source, failures);
-      if (outcome.ok && outcome.value !== void 0) {
-        out[key] = outcome.value;
-      }
-    }
-    if (failures.length > 0) {
-      throw new LunoraEnvError(failures);
-    }
-    return out;
-  };
-  return accessor;
-};
-
-export { LunoraEnvError, defineEnv, redactSecrets };

package/dist/packem_shared/LunoraError-WbxmrpxR.mjs

@@ -1,9 +0,0 @@
-import { LunoraError as LunoraError$1 } from '@lunora/errors';
-
-class LunoraError extends LunoraError$1 {
-  constructor(code, message, data) {
-    super(code, message, { data });
-  }
-}
-
-export { LunoraError };

package/dist/packem_shared/PRESENCE_DEFAULT_TTL_MS-Cr0i4mTv.mjs

@@ -1,114 +0,0 @@
-import { v } from '@lunora/values';
-import { initLunora } from './initLunora-D0Wuki7S.mjs';
-import { LunoraError } from './LunoraError-WbxmrpxR.mjs';
-import { onDisconnect } from './onConnect-CIPXKPyw.mjs';
-import { defineSchemaExtension, defineComponent } from './composePluginMiddleware-z62dttBo.mjs';
-import { defineTable } from './defineAggregateIndex-cdo0g-un.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 && new TextEncoder().encode(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/asBucketStorage-Cnxd9y2q.mjs

@@ -1,11 +0,0 @@
-const asBucketStorage = (raw) => {
-  const candidate = raw ?? {};
-  if (typeof candidate.bucket === "function") {
-    return candidate;
-  }
-  const self = { ...candidate, bucketName: "default" };
-  self.bucket = () => self;
-  return self;
-};
-
-export { asBucketStorage as default };