@noy-db/hub 0.7.0 → 0.8.0-pre.0

package/dist/chunk-X25NWUZB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/with-formula/materialized-views/with-materialized-view.ts"],"sourcesContent":["import { MaterializedViewConfigError, ValidationError } from '../../kernel/errors.js'\nimport type { MaterializedViewSpec, MaterializedViewStrategy } from './types.js'\nimport { validateProjectionLegs } from './projection-legs.js' // #1140\nimport { describeGroupKey } from '../../kernel/query/reduce/date-trunc.js'\n\n/**\n * Register a materialized view: a declared query whose result is\n * persisted as a queryable collection and kept fresh as sources\n * change. Writes go through the standard `Collection.put` pipeline;\n * refresh-driven deletes route through `Collection._internalDelete` so\n * user `onDelete` guards on the output collection aren't tripped by\n * housekeeping.\n *\n * Three registration modes:\n *   - **single-source** — declare `query: (db) => Query<TRow>`; the\n *     dependency analyzer derives source collections from the plan.\n *   - **UNION** — declare `unionSources: [{ collection, map }, ...]`\n *     plus optional `groupBy` + `aggregate`; the executor reads each\n *     arm, maps to the unified row shape, concatenates, then groups\n *     and aggregates.\n *   - **projection** (#810) — declare `projection: { source, joins,\n *     map }`; one output row per primary record, enriched with\n *     forward FK legs and reverse \"collect\" legs before `map` runs.\n *\n * The three modes are mutually exclusive — exactly one of `query` /\n * `unionSources` / `projection` must be set at registration time.\n *\n * See design-history/2026-05-20-dim14-mv-v2-design.md (single-source v2),\n * design-history/2026-05-21-dim14-mv-multikey-and-union.md (UNION),\n * and design-history/2026-07-25-join-projection-mv-design.md (projection).\n */\nexport function withMaterializedView<TRow extends Record<string, unknown>>(\n  spec: MaterializedViewSpec<TRow>,\n): MaterializedViewStrategy {\n  if (!spec.name || spec.name.length === 0) {\n    throw new ValidationError('withMaterializedView: name is required')\n  }\n  // Mutual exclusion: exactly one of the three forms must be declared.\n  const declaredForms = [spec.query, spec.unionSources, spec.projection]\n    .filter((f) => f !== undefined).length\n  if (declaredForms > 1) {\n    throw new MaterializedViewConfigError(\n      'query, unionSources, and projection are mutually exclusive — pick one',\n    )\n  }\n  if (declaredForms === 0) {\n    throw new MaterializedViewConfigError(\n      'strategy must declare exactly one of query, unionSources, or projection',\n    )\n  }\n  if (spec.query !== undefined && typeof spec.query !== 'function') {\n    throw new ValidationError('withMaterializedView: query must be a function returning a Query<T>')\n  }\n  // UNION-form invariants.\n  if (spec.unionSources) {\n    // A single arm is a deliberate shape: map→group→aggregate over\n    // ONE collection with a COMPUTED bucket key (e.g. month sliced from a\n    // date field) — something the query form's stored-field groupBy cannot\n    // express. The executor and dependency analyzer are arm-count-agnostic.\n    if (spec.unionSources.length < 1) {\n      throw new MaterializedViewConfigError(\n        'unionSources requires at least 1 source collection',\n      )\n    }\n    const seen = new Set<string>()\n    for (const s of spec.unionSources) {\n      if (typeof s?.collection !== 'string' || s.collection.length === 0) {\n        throw new MaterializedViewConfigError(\n          'each unionSources entry must declare a non-empty `collection` string',\n        )\n      }\n      if (typeof s.map !== 'function') {\n        throw new MaterializedViewConfigError(\n          `unionSources entry for \"${s.collection}\" is missing a \\`map\\` function`,\n        )\n      }\n      if (seen.has(s.collection)) {\n        throw new MaterializedViewConfigError(\n          `unionSources must reference distinct collections (duplicate: \"${s.collection}\")`,\n        )\n      }\n      seen.add(s.collection)\n    }\n    if (Array.isArray(spec.groupBy) && spec.groupBy.length === 0) {\n      throw new MaterializedViewConfigError(\n        `withMaterializedView \"${spec.name}\": groupBy must not be an empty array — omit it or provide at least one field name`,\n      )\n    }\n    if (spec.aggregate && !spec.groupBy) {\n      throw new MaterializedViewConfigError(\n        `withMaterializedView \"${spec.name}\": UNION strategy with aggregate requires groupBy — `\n        + `use groupBy to declare the bucketing keys, or remove aggregate for a pure dedup MV`,\n      )\n    }\n    // `moneyFields` only has meaning when there's a reducer to money-rewrite —\n    // it keys reducer outputs, so declaring it with neither is a no-op config\n    // mistake.\n    //\n    // ⚠️ #1411 widened this: a WINDOW's reducer slots are money-rewritten by\n    // the same binding, so `moneyFields` is meaningful for a view that\n    // declares a window and no aggregate — which is exactly the pilot's\n    // per-row running total. Before the widening this guard refused that view\n    // with a message about aggregates it was not trying to use.\n    if (spec.moneyFields && !spec.aggregate && !spec.window) {\n      throw new MaterializedViewConfigError(\n        `withMaterializedView \"${spec.name}\": moneyFields requires aggregate or window — `\n        + `moneyFields rewrites sum/min/max reducers over money output fields, `\n        + `so it is meaningless without one`,\n      )\n    }\n    // Per-arm joins resolve right-side collections that the union\n    // dependency set (built from arm `collection`s alone) does NOT\n    // include. The consumer must list those right-side collections in\n    // `sources` so writes to them trigger MV refresh.\n    // #1411 — declared (`on`) legs name their target literally and fold it in\n    // themselves; only ref legs need the consumer to list the right side.\n    if (spec.unionSources.some(s => s.join?.some(leg => !('on' in leg))) && (!spec.sources || spec.sources.length === 0)) {\n      throw new MaterializedViewConfigError(\n        `withMaterializedView \"${spec.name}\": a unionSources arm declares join(s) but `\n        + `no \\`sources\\` are listed — declare sources: [...] with the right-side `\n        + `(join-target) collection names so writes to them trigger MV refresh`,\n      )\n    }\n    if (spec.predicates) {\n      throw new MaterializedViewConfigError(\n        `withMaterializedView \"${spec.name}\": predicates are not supported on UNION strategies — `\n        + `UNION mode does not use a Query<T> chain, so .wherePredicate() cannot fire. `\n        + `Use the query() form, or open an issue if per-arm predicates are needed`,\n      )\n    }\n  }\n  // #1411 — window-form invariants. Shared by UNION and projection, since the\n  // stage runs at both exits from the grouping tail.\n  if (spec.window) {\n    if (spec.query) {\n      throw new MaterializedViewConfigError(\n        `withMaterializedView \"${spec.name}\": window is not supported on the query() form — `\n        + `the rows come from a Query, which has its own .window(...).select(...). `\n        + `window is for the unionSources / projection forms, whose rows are mapped`,\n      )\n    }\n    if (typeof spec.window.select !== 'object' || spec.window.select === null\n        || Object.keys(spec.window.select).length === 0) {\n      throw new MaterializedViewConfigError(\n        `withMaterializedView \"${spec.name}\": window.select must declare at least one output — `\n        + `a window that selects nothing computes nothing, so declaring one is `\n        + `more likely a mistake than an intention`,\n      )\n    }\n    // Same rule `derive` has, and the same reason: a group key is the row's\n    // identity and feeds rowKey, so writing one from a later stage would\n    // silently re-home the row.\n    const groupFields = new Set<string>(\n      spec.groupBy === undefined\n        ? []\n        : (Array.isArray(spec.groupBy) ? spec.groupBy : [spec.groupBy]).map(describeGroupKey),\n    )\n    for (const key of Object.keys(spec.window.select)) {\n      if (groupFields.has(key)) {\n        throw new MaterializedViewConfigError(\n          `withMaterializedView \"${spec.name}\": window.select[\"${key}\"] collides with a groupBy key — `\n          + `a group key is the row's identity and feeds rowKey, so a window output `\n          + `may not overwrite it. Pick another name for the window column`,\n        )\n      }\n    }\n  }\n\n  // Projection-form invariants (#810). Shape checks only — the\n  // semantic ref() check on collect legs (the `on` field must carry a\n  // ref() targeting the projection source) runs at first\n  // materialization, parity with join-time ref errors.\n  if (spec.projection) {\n    const projection = spec.projection\n    if (typeof projection.source !== 'string' || projection.source.length === 0) {\n      throw new MaterializedViewConfigError(\n        `withMaterializedView \"${spec.name}\": projection.source must be a non-empty collection name`,\n      )\n    }\n    if (typeof projection.map !== 'function') {\n      throw new MaterializedViewConfigError(\n        `withMaterializedView \"${spec.name}\": projection is missing a \\`map\\` function`,\n      )\n    }\n    if (!Array.isArray(projection.joins) || projection.joins.length < 1) {\n      throw new MaterializedViewConfigError(\n        `withMaterializedView \"${spec.name}\": projection.joins must declare at least 1 leg — `\n        + `a leg-less single-source MV is the query() form's job`,\n      )\n    }\n    const seenAs = new Set<string>()\n    for (const leg of projection.joins) {\n      const l = leg as { field?: unknown; collect?: unknown; on?: unknown; as?: unknown }\n      const isForward = l.field !== undefined\n      const isCollect = l.collect !== undefined\n      if (isForward && isCollect) {\n        throw new MaterializedViewConfigError(\n          `withMaterializedView \"${spec.name}\": a projection leg cannot declare both \\`field\\` `\n          + `(forward) and \\`collect\\` (reverse) — split it into two legs`,\n        )\n      }\n      if (!isForward && !isCollect) {\n        throw new MaterializedViewConfigError(\n          `withMaterializedView \"${spec.name}\": each projection leg must declare either \\`field\\` `\n          + `(forward FK) or \\`collect\\` (reverse one-to-many)`,\n        )\n      }\n      if (isForward && (typeof l.field !== 'string' || l.field.length === 0)) {\n        throw new MaterializedViewConfigError(\n          `withMaterializedView \"${spec.name}\": a forward projection leg must declare a non-empty \\`field\\``,\n        )\n      }\n      if (isCollect) {\n        if (typeof l.collect !== 'string' || l.collect.length === 0) {\n          throw new MaterializedViewConfigError(\n            `withMaterializedView \"${spec.name}\": a collect projection leg must declare a non-empty \\`collect\\` collection name`,\n          )\n        }\n        if (typeof l.on !== 'string' || l.on.length === 0) {\n          throw new MaterializedViewConfigError(\n            `withMaterializedView \"${spec.name}\": collect leg for \"${l.collect}\" must declare a non-empty \\`on\\` FK field`,\n          )\n        }\n      }\n      if (typeof l.as !== 'string' || l.as.length === 0) {\n        throw new MaterializedViewConfigError(\n          `withMaterializedView \"${spec.name}\": each projection leg must declare a non-empty \\`as\\` alias`,\n        )\n      }\n      if (seenAs.has(l.as)) {\n        throw new MaterializedViewConfigError(\n          `withMaterializedView \"${spec.name}\": projection legs must attach under distinct \\`as\\` aliases (duplicate: \"${l.as}\")`,\n        )\n      }\n      seenAs.add(l.as)\n    }\n    // #1140 — `from` wiring, checked here with the rest of the leg shape rather\n    // than at vault open: it is pure configuration, so the earliest failure is\n    // the best one. Owned by `projection-legs.ts` because the executor and the\n    // registry both walk the same graph.\n    validateProjectionLegs(spec.name, spec.projection)\n    // Post-map grouping invariants — same rules as UNION (the mapped\n    // stream feeds the same shared groupAndReduce tail).\n    if (Array.isArray(spec.groupBy) && spec.groupBy.length === 0) {\n      throw new MaterializedViewConfigError(\n        `withMaterializedView \"${spec.name}\": groupBy must not be an empty array — omit it or provide at least one field name`,\n      )\n    }\n    if (spec.aggregate && !spec.groupBy) {\n      throw new MaterializedViewConfigError(\n        `withMaterializedView \"${spec.name}\": projection strategy with aggregate requires groupBy — `\n        + `use groupBy to declare the bucketing keys, or remove aggregate for a row-per-primary-record MV`,\n      )\n    }\n    if (spec.moneyFields && !spec.aggregate && !spec.window) {\n      throw new MaterializedViewConfigError(\n        `withMaterializedView \"${spec.name}\": moneyFields requires aggregate or window — `\n        + `moneyFields rewrites sum/min/max reducers over money output fields, `\n        + `so it is meaningless without one`,\n      )\n    }\n    if (spec.predicates) {\n      throw new MaterializedViewConfigError(\n        `withMaterializedView \"${spec.name}\": predicates are not supported on projection strategies — `\n        + `projection mode does not use a Query<T> chain, so .wherePredicate() cannot fire. `\n        + `Filter inside projection.map (return null to omit) instead`,\n      )\n    }\n  }\n  // i18nLocale + i18nFields drive compute-time i18n resolution of group-key\n  // i18nText fields before bucketing — UNION mode (resolved on the unified rows)\n  // AND query mode (resolved in GroupedReduction.run before groupAndReduce).\n  // i18nLocale without i18nFields cannot resolve anything, so reject it early.\n  if (spec.i18nLocale !== undefined && spec.i18nFields === undefined) {\n    throw new MaterializedViewConfigError(\n      `withMaterializedView \"${spec.name}\": i18nLocale requires i18nFields — `\n      + `declare the i18nText descriptors of the group-key fields so they can be `\n      + `resolved at the mv layer before bucketing.`,\n    )\n  }\n  if (typeof spec.rowKey !== 'function') {\n    // Two states, two messages. The original text said \"required\" for BOTH,\n    // so passing a field NAME — the shape every other option here takes —\n    // reported the key as ABSENT. That collapse cost this author three\n    // attempts and produced a probe that measured nothing.\n    throw new ValidationError(\n      spec.rowKey === undefined\n        ? 'withMaterializedView: rowKey is required (no default; see spec § Type surface)'\n        : `withMaterializedView: rowKey must be a FUNCTION (row) => string, not a ${typeof spec.rowKey}`\n          + ` — it computes each output row's id from the grouped row, so a field NAME is not enough.`\n          + ` Pass \\`rowKey: (r) => String(r.${typeof spec.rowKey === 'string' ? String(spec.rowKey) : 'someField'})\\`.`)\n  }\n  if (spec.refresh !== 'eager' && spec.refresh !== 'lazy' && spec.refresh !== 'manual') {\n    throw new ValidationError(\n      `withMaterializedView: refresh must be 'eager' | 'lazy' | 'manual', got \"${String(spec.refresh)}\"`,\n    )\n  }\n  return {\n    __noydb_strategy: 'materialized-view',\n    spec,\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-Q7HZX3IF.js → chunk-X4773RBR.js}

@@ -1,6 +1,6 @@
 import {
   AttestationNotEnabledError
-} from "./chunk-7O3Y4PPD.js";
+} from "./chunk-244VXYPG.js";
 
 // src/with-audit/attestation/strategy.ts
 var NO_ATTESTATION = {
@@ -27,4 +27,4 @@ var NO_ATTESTATION = {
 export {
   NO_ATTESTATION
 };
-//# sourceMappingURL=chunk-Q7HZX3IF.js.map
+//# sourceMappingURL=chunk-X4773RBR.js.map

package/dist/chunk-XBKH4FOC.js

@@ -0,0 +1,195 @@
+// src/kernel/query/civil-date.ts
+var CIVIL = /^(\d{4})(?:-(\d{1,2})(?:-(\d{1,2})(?:[T ]\d{1,2}:\d{2}(?::\d{2}(?:\.\d+)?)?)?)?)?$/;
+function daysInMonth(y, m) {
+  if (m === 2) return y % 4 === 0 && y % 100 !== 0 || y % 400 === 0 ? 29 : 28;
+  return m === 4 || m === 6 || m === 9 || m === 11 ? 30 : 31;
+}
+function civilDateOf(value) {
+  if (typeof value !== "string") return void 0;
+  const match = CIVIL.exec(value);
+  if (match === null) return void 0;
+  const y = Number(match[1]);
+  const m = match[2] === void 0 ? 1 : Number(match[2]);
+  const d = match[3] === void 0 ? 1 : Number(match[3]);
+  if (m < 1 || m > 12 || d < 1 || d > daysInMonth(y, m)) return "invalid";
+  return { y, m, d };
+}
+
+// src/kernel/query/reduce/date-trunc.ts
+var UNITS = ["day", "week", "month", "quarter", "year"];
+var WEEK_STARTS = ["monday", "sunday"];
+function dateTrunc(field, unit, options) {
+  if (typeof field !== "string" || field.length === 0) {
+    throw new Error("dateTrunc(): field must be a non-empty field name.");
+  }
+  if (!UNITS.includes(unit)) {
+    throw new Error(
+      `dateTrunc("${field}"): unknown unit "${String(unit)}". Expected one of ${UNITS.join(", ")}.`
+    );
+  }
+  const timeZone = options?.timeZone;
+  if (typeof timeZone !== "string" || timeZone.length === 0) {
+    throw new Error(
+      `dateTrunc("${field}", "${unit}"): timeZone is required. An accounting period is a local-calendar fact, so there is no safe host-local default \u2014 pass an IANA zone (e.g. { timeZone: 'Europe/Berlin' }), or { timeZone: 'UTC' } to bucket in UTC.`
+    );
+  }
+  try {
+    formatterFor(timeZone);
+  } catch {
+    throw new Error(
+      `dateTrunc("${field}", "${unit}"): unknown timeZone "${timeZone}". Expected an IANA zone name.`
+    );
+  }
+  const weekStartsOn = options.weekStartsOn ?? "monday";
+  if (!WEEK_STARTS.includes(weekStartsOn)) {
+    throw new Error(
+      `dateTrunc("${field}", "${unit}"): weekStartsOn must be ${WEEK_STARTS.join(" or ")}.`
+    );
+  }
+  return {
+    __dateTrunc: true,
+    field,
+    unit,
+    timeZone,
+    weekStartsOn,
+    as: options.as ?? `${field.replaceAll(".", "_")}_${unit}`
+  };
+}
+function isDateTruncKey(value) {
+  return typeof value === "object" && value !== null && value.__dateTrunc === true;
+}
+function groupKeyName(key) {
+  return isDateTruncKey(key) ? key.as : key;
+}
+function groupKeySourceField(key) {
+  return isDateTruncKey(key) ? key.field : key;
+}
+function describeGroupKey(key) {
+  if (!isDateTruncKey(key)) return key;
+  return `dateTrunc(${key.field}|${key.unit}|${key.timeZone}|${key.weekStartsOn}|${key.as})`;
+}
+function truncateDate(value, key) {
+  if (value === null || value === void 0) return value;
+  const { y, m, d } = resolveCivilDate(value, key);
+  switch (key.unit) {
+    case "day":
+      return ymd(y, m, d);
+    case "month":
+      return ymd(y, m, 1);
+    case "quarter":
+      return ymd(y, m - (m - 1) % 3, 1);
+    case "year":
+      return ymd(y, 1, 1);
+    case "week": {
+      const days = daysFromCivil(y, m, d);
+      const sundayIndex = ((days % 7 + 7) % 7 + 4) % 7;
+      const back = key.weekStartsOn === "monday" ? (sundayIndex + 6) % 7 : sundayIndex;
+      const start = civilFromDays(days - back);
+      return ymd(start.y, start.m, start.d);
+    }
+  }
+}
+function projectDateTruncKeys(rows, keys) {
+  return rows.map((row) => {
+    const next = { ...row };
+    for (const key of keys) {
+      next[key.as] = truncateDate(readFieldPath(next, key.field), key);
+    }
+    return next;
+  });
+}
+function readFieldPath(row, path) {
+  if (!path.includes(".")) return row[path];
+  let cur = row;
+  for (const seg of path.split(".")) {
+    if (cur === null || cur === void 0 || typeof cur !== "object") return void 0;
+    cur = cur[seg];
+  }
+  return cur;
+}
+function resolveCivilDate(value, key) {
+  const civil = civilDateOf(value);
+  if (civil === "invalid") {
+    throw new Error(
+      `dateTrunc("${key.field}", "${key.unit}"): value ${JSON.stringify(value)} is a calendar date shape but names no real day.`
+    );
+  }
+  if (civil !== void 0) return civil;
+  const ms = toEpochMs(value);
+  if (ms === void 0) {
+    throw new Error(
+      `dateTrunc("${key.field}", "${key.unit}"): value ${JSON.stringify(value) ?? typeof value} is not a timestamp. Expected a Date, epoch milliseconds, or a parseable date string.`
+    );
+  }
+  return localCivilDate(ms, key.timeZone);
+}
+function toEpochMs(value) {
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? void 0 : value.getTime();
+  if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+  if (typeof value === "string") {
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? void 0 : parsed;
+  }
+  return void 0;
+}
+var formatters = /* @__PURE__ */ new Map();
+function formatterFor(timeZone) {
+  let f = formatters.get(timeZone);
+  if (!f) {
+    f = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
+    });
+    formatters.set(timeZone, f);
+  }
+  return f;
+}
+function localCivilDate(ms, timeZone) {
+  let y = 0;
+  let m = 0;
+  let d = 0;
+  for (const part of formatterFor(timeZone).formatToParts(new Date(ms))) {
+    if (part.type === "year") y = Number(part.value);
+    else if (part.type === "month") m = Number(part.value);
+    else if (part.type === "day") d = Number(part.value);
+  }
+  return { y, m, d };
+}
+function ymd(y, m, d) {
+  return `${String(y).padStart(4, "0")}-${String(m).padStart(2, "0")}-${String(d).padStart(2, "0")}`;
+}
+function daysFromCivil(y, m, d) {
+  const yy = m <= 2 ? y - 1 : y;
+  const era = Math.floor(yy / 400);
+  const yoe = yy - era * 400;
+  const doy = Math.floor((153 * (m + (m > 2 ? -3 : 9)) + 2) / 5) + d - 1;
+  const doe = yoe * 365 + Math.floor(yoe / 4) - Math.floor(yoe / 100) + doy;
+  return era * 146097 + doe - 719468;
+}
+function civilFromDays(z) {
+  const shifted = z + 719468;
+  const era = Math.floor(shifted / 146097);
+  const doe = shifted - era * 146097;
+  const yoe = Math.floor(
+    (doe - Math.floor(doe / 1460) + Math.floor(doe / 36524) - Math.floor(doe / 146096)) / 365
+  );
+  const y = yoe + era * 400;
+  const doy = doe - (365 * yoe + Math.floor(yoe / 4) - Math.floor(yoe / 100));
+  const mp = Math.floor((5 * doy + 2) / 153);
+  const d = doy - Math.floor((153 * mp + 2) / 5) + 1;
+  const m = mp + (mp < 10 ? 3 : -9);
+  return { y: m <= 2 ? y + 1 : y, m, d };
+}
+
+export {
+  dateTrunc,
+  isDateTruncKey,
+  groupKeyName,
+  groupKeySourceField,
+  describeGroupKey,
+  truncateDate,
+  projectDateTruncKeys
+};
+//# sourceMappingURL=chunk-XBKH4FOC.js.map

package/dist/chunk-XBKH4FOC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/kernel/query/civil-date.ts","../src/kernel/query/reduce/date-trunc.ts"],"sourcesContent":["/**\n * Civil-date recognition for `dateTrunc()` (#1410).\n *\n * ## Why this module exists\n *\n * `dateTrunc()` buckets a value by resolving it to an instant and reading the\n * civil calendar date that instant falls on in the declared `timeZone`. That is\n * exactly right for a *timestamp*. It is a **category error** for a value that\n * names no instant.\n *\n * `'2026-01-01'` — the shape `z.string().date()` produces — is a calendar date.\n * ECMA-262 nonetheless resolves the ISO date-only form to **UTC midnight**, and\n * converting that instant into any zone west of UTC moves it back a day. So\n * `dateTrunc(..., 'month', { timeZone: 'America/New_York' })` silently bucketed\n * `'2026-01-01'` into `2025-12` — a wrong year, no error, no warning. Correct at\n * `+07` and UTC purely by accident of sign, which is what made it latent.\n *\n * ## The rule\n *\n * **A string carrying no timezone designator denotes CIVIL time and is used as\n * written. Everything else is an instant and is converted through the zone.**\n *\n * That covers three shapes, all of which are zoneless:\n *\n * | input | denotes | why |\n * |---|---|---|\n * | `'2026-01-01'`, `'2026-01'`, `'2026'` | civil | ISO calendar forms; no time, no zone |\n * | `'2026-01-01T08:30'`, `'2026-01-01 08:30:00.5'` | civil | offsetless date-time |\n * | `'2026-01-01T00:00:00Z'`, `'…+07:00'`, `Date`, epoch ms | instant | carries, or *is*, a fixed point in time |\n *\n * The offsetless date-time is the subtle one and it is included **deliberately**.\n * ECMA-262 parses it as *host-local*, which is the same defect one layer down:\n * the bucket would depend on the machine the query ran on, and this module's\n * whole premise (see `date-trunc.ts`) is that a host-local guess is never\n * acceptable. Reading it as civil makes the result host-independent. The\n * time-of-day is then simply discarded — every `dateTrunc` unit is a day or\n * coarser, so no unit can observe it.\n *\n * ⚠️ **Loose, non-ISO strings are NOT recognised here** — `'01/01/2026'`,\n * RFC-2822, and anything else `Date.parse` accepts by implementation extension\n * stay on the instant path. Their parsing is implementation-defined, so there\n * is no shape this module could claim to recognise correctly; a consumer who\n * wants civil treatment should pass an ISO calendar date.\n *\n * ⚠️ **An out-of-range field is REFUSED, not rolled over.** V8's `Date.parse`\n * accepts `'2026-02-30'` and yields 2 March; bucketing a typo under a\n * wrong-but-plausible key is the failure mode this whole module exists to\n * prevent, so a recognised-shape-but-impossible date throws instead.\n */\n\n/** A calendar date with no instant and no zone. `m` is 1-12. */\nexport interface CivilDate {\n  readonly y: number\n  readonly m: number\n  readonly d: number\n}\n\n/**\n * `YYYY[-M[-D[(T| )HH:MM[:SS[.fff]]]]]` and nothing else — in particular no\n * trailing `Z` and no `±HH:MM`, which are precisely the designators that turn\n * the string into an instant.\n */\nconst CIVIL =\n  /^(\\d{4})(?:-(\\d{1,2})(?:-(\\d{1,2})(?:[T ]\\d{1,2}:\\d{2}(?::\\d{2}(?:\\.\\d+)?)?)?)?)?$/\n\n/** Days in `m` of `y`, proleptic Gregorian. */\nfunction daysInMonth(y: number, m: number): number {\n  if (m === 2) return (y % 4 === 0 && y % 100 !== 0) || y % 400 === 0 ? 29 : 28\n  return m === 4 || m === 6 || m === 9 || m === 11 ? 30 : 31\n}\n\n/**\n * What a value denotes:\n *   - a {@link CivilDate} — a zoneless calendar shape, use it as written;\n *   - `'invalid'` — a recognised calendar shape naming no real day (see the\n *     out-of-range note above); the caller refuses it with its own context;\n *   - `undefined` — an instant, or an unrecognised shape: convert through the\n *     declared zone exactly as before.\n */\nexport function civilDateOf(value: unknown): CivilDate | 'invalid' | undefined {\n  if (typeof value !== 'string') return undefined\n  const match = CIVIL.exec(value)\n  if (match === null) return undefined\n  const y = Number(match[1])\n  const m = match[2] === undefined ? 1 : Number(match[2])\n  const d = match[3] === undefined ? 1 : Number(match[3])\n  if (m < 1 || m > 12 || d < 1 || d > daysInMonth(y, m)) return 'invalid'\n  return { y, m, d }\n}\n","/**\n * Calendar bucketing for group keys — `dateTrunc()` (#1350).\n *\n * ```ts\n * invoices.query()\n *   .groupBy(dateTrunc('issuedAt', 'month', { timeZone: 'Europe/Berlin' }))\n *   .aggregate({ total: sum('amount') })\n *   .run()\n * // → [ { issuedAt_month: '2026-09-01', total: 5250 }, … ]\n * ```\n *\n * ## The timezone is a REQUIRED parameter, never a host-local guess\n *\n * An accounting period is a local-calendar fact: \"September\" means the\n * September of some jurisdiction's calendar, and the same instant belongs to\n * different months depending on which. A host-local default would make the\n * same query produce different rollups on a laptop in Berlin and a CI runner\n * in UTC — silently, with no error and a plausible-looking number. So\n * `timeZone` has no default: omit it and the descriptor is refused at\n * construction, which is also where an unknown zone is caught.\n *\n * ## The bucket value is the local calendar date of the bucket START\n *\n * Every unit produces `'YYYY-MM-DD'`: `'2026-09-01'` for September 2026,\n * `'2026-07-01'` for Q3, `'2026-01-01'` for the year, `'2026-08-31'` for the\n * ISO week containing 3 September. One shape for all five units, lexically\n * sortable, and free of the week-numbering ambiguity that `'2026-W36'` would\n * drag in (ISO week-years disagree with calendar years at the boundary, and\n * ISO week numbers are undefined for a sunday-start week).\n *\n * ## Week start\n *\n * `weekStartsOn` defaults to `'monday'` (ISO-8601). `'sunday'` is the other\n * accepted value. It is only consulted for `unit: 'week'`, but it is part of\n * the descriptor's identity either way, so it folds into the queryHash.\n *\n * ## DST\n *\n * No arithmetic is ever done on a timestamp. The instant is resolved to a\n * local civil date through `Intl.DateTimeFormat` (the platform's own tz\n * database), and every truncation from there is pure civil-calendar\n * arithmetic. A 23-hour or 25-hour local day therefore needs no special case:\n * both ends of it format to the same local date.\n *\n * ## A ZONELESS value is a civil date, and the timeZone does not apply to it\n *\n * `'2026-01-01'` — what `z.string().date()` produces — names a calendar day,\n * not an instant. It is bucketed as written, in every zone. Applying a zone to\n * it is a category error, and an expensive one: ECMA-262 resolves the ISO\n * date-only form to UTC midnight, so before #1410 that value bucketed into\n * **2025-12** for `America/New_York` — a wrong year, silently. The same holds\n * for an offsetless date-time, which ECMA-262 would otherwise read as\n * *host*-local. A `Date`, epoch millis, or a string carrying `Z` or an offset\n * IS an instant and still converts through `timeZone`. See `civil-date.ts`.\n *\n * Portability: `Intl` is a language global, so this file stays inside hub's\n * no-Node-built-ins boundary and adds no dependency.\n */\nimport { civilDateOf } from '../civil-date.js'\n\n/** Calendar units `dateTrunc()` can bucket into. */\nexport type DateTruncUnit = 'day' | 'week' | 'month' | 'quarter' | 'year'\n\n/** Accepted week-start conventions. Default is `'monday'` (ISO-8601). */\nexport type WeekStart = 'monday' | 'sunday'\n\nconst UNITS: readonly DateTruncUnit[] = ['day', 'week', 'month', 'quarter', 'year']\nconst WEEK_STARTS: readonly WeekStart[] = ['monday', 'sunday']\n\n/**\n * A derived group key: \"bucket `field` to the start of its `unit`, in\n * `timeZone`\". Opaque to consumers — build it with {@link dateTrunc}.\n */\nexport interface DateTruncKey {\n  readonly __dateTrunc: true\n  /** Source field (a `readPath` path — dots address nested values). */\n  readonly field: string\n  readonly unit: DateTruncUnit\n  /** IANA zone name. Always explicit; validated at construction. */\n  readonly timeZone: string\n  readonly weekStartsOn: WeekStart\n  /** Output key the bucket is stamped under on each result row. */\n  readonly as: string\n}\n\n/** Either a plain field name or a derived calendar key. */\nexport type GroupKey = string | DateTruncKey\n\nexport interface DateTruncOptions {\n  /**\n   * IANA timezone the calendar is read in — REQUIRED. See the module note:\n   * there is no safe default, so there is no default.\n   *\n   * It applies to values that ARE instants. A zoneless calendar string\n   * (`'2026-01-01'`, `'2026-01-01T08:30'`) has no instant to convert and is\n   * bucketed as written regardless of what is passed here (#1410).\n   */\n  timeZone: string\n  /** Week-start convention for `unit: 'week'`. Default `'monday'`. */\n  weekStartsOn?: WeekStart\n  /**\n   * Output key. Defaults to `<field>_<unit>` with dots flattened to\n   * underscores, so a nested source path cannot produce an output key that\n   * `readPath` would then re-interpret as a path.\n   */\n  as?: string\n}\n\n/**\n * Declare a calendar-bucketed group key. Composable with plain field names in\n * a multi-key `.groupBy(...)`.\n */\nexport function dateTrunc(\n  field: string,\n  unit: DateTruncUnit,\n  options: DateTruncOptions,\n): DateTruncKey {\n  if (typeof field !== 'string' || field.length === 0) {\n    throw new Error('dateTrunc(): field must be a non-empty field name.')\n  }\n  if (!UNITS.includes(unit)) {\n    throw new Error(\n      `dateTrunc(\"${field}\"): unknown unit \"${String(unit)}\". Expected one of ${UNITS.join(', ')}.`,\n    )\n  }\n  const timeZone = options?.timeZone\n  if (typeof timeZone !== 'string' || timeZone.length === 0) {\n    throw new Error(\n      `dateTrunc(\"${field}\", \"${unit}\"): timeZone is required. An accounting period is a ` +\n        `local-calendar fact, so there is no safe host-local default — pass an IANA zone ` +\n        `(e.g. { timeZone: 'Europe/Berlin' }), or { timeZone: 'UTC' } to bucket in UTC.`,\n    )\n  }\n  try {\n    formatterFor(timeZone)\n  } catch {\n    throw new Error(\n      `dateTrunc(\"${field}\", \"${unit}\"): unknown timeZone \"${timeZone}\". Expected an IANA zone name.`,\n    )\n  }\n  const weekStartsOn = options.weekStartsOn ?? 'monday'\n  if (!WEEK_STARTS.includes(weekStartsOn)) {\n    throw new Error(\n      `dateTrunc(\"${field}\", \"${unit}\"): weekStartsOn must be ${WEEK_STARTS.join(' or ')}.`,\n    )\n  }\n  return {\n    __dateTrunc: true,\n    field,\n    unit,\n    timeZone,\n    weekStartsOn,\n    as: options.as ?? `${field.replaceAll('.', '_')}_${unit}`,\n  }\n}\n\n/** Runtime discriminator — a `DateTruncKey` vs a plain field name. */\nexport function isDateTruncKey(value: unknown): value is DateTruncKey {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as { __dateTrunc?: unknown }).__dateTrunc === true\n  )\n}\n\n/** Output key a group key stamps on the result row. */\nexport function groupKeyName(key: GroupKey): string {\n  return isDateTruncKey(key) ? key.as : key\n}\n\n/**\n * Source field a group key READS. Differs from {@link groupKeyName} only for a\n * derived key — guards that ask \"is this field stored?\" want this one.\n */\nexport function groupKeySourceField(key: GroupKey): string {\n  return isDateTruncKey(key) ? key.field : key\n}\n\n/**\n * Canonical, stable description of a group key for hashing. Every parameter\n * that changes which bucket a row lands in appears here, so declaring,\n * removing, or re-parameterising a derived key bumps an MV's `queryHash`.\n * Pipe-separated so a description can never be confused with the\n * comma-separated field list it sits inside.\n */\nexport function describeGroupKey(key: GroupKey): string {\n  if (!isDateTruncKey(key)) return key\n  return `dateTrunc(${key.field}|${key.unit}|${key.timeZone}|${key.weekStartsOn}|${key.as})`\n}\n\n/**\n * Truncate one value to its bucket. `null` / `undefined` pass through\n * unchanged so the existing null-vs-undefined bucket semantics of\n * `groupAndReduce` still apply. Anything else that is not a timestamp is\n * REFUSED rather than bucketed under a wrong-but-plausible key.\n */\nexport function truncateDate(value: unknown, key: DateTruncKey): string | null | undefined {\n  if (value === null || value === undefined) return value\n  const { y, m, d } = resolveCivilDate(value, key)\n  switch (key.unit) {\n    case 'day':\n      return ymd(y, m, d)\n    case 'month':\n      return ymd(y, m, 1)\n    case 'quarter':\n      return ymd(y, m - ((m - 1) % 3), 1)\n    case 'year':\n      return ymd(y, 1, 1)\n    case 'week': {\n      const days = daysFromCivil(y, m, d)\n      // 1970-01-01 (day 0) was a Thursday; +4 shifts to a sunday-indexed week.\n      const sundayIndex = (((days % 7) + 7) % 7 + 4) % 7\n      const back = key.weekStartsOn === 'monday' ? (sundayIndex + 6) % 7 : sundayIndex\n      const start = civilFromDays(days - back)\n      return ymd(start.y, start.m, start.d)\n    }\n  }\n}\n\n/**\n * Stamp each derived key's bucket onto a shallow copy of every row, so the\n * downstream grouping pipeline sees an ordinary stored field. Input rows are\n * never mutated.\n */\nexport function projectDateTruncKeys<R>(\n  rows: readonly R[],\n  keys: readonly DateTruncKey[],\n): R[] {\n  return rows.map((row) => {\n    const next = { ...(row as Record<string, unknown>) }\n    for (const key of keys) {\n      next[key.as] = truncateDate(readFieldPath(next, key.field), key)\n    }\n    return next as R\n  })\n}\n\n// ─── internals ──────────────────────────────────────────────────────────────\n\n/**\n * Local `readPath`. Duplicating six lines from `predicate.ts` keeps this\n * module importable from the MV executor without dragging the query\n * predicate evaluator in behind it.\n */\nfunction readFieldPath(row: Record<string, unknown>, path: string): unknown {\n  if (!path.includes('.')) return row[path]\n  let cur: unknown = row\n  for (const seg of path.split('.')) {\n    if (cur === null || cur === undefined || typeof cur !== 'object') return undefined\n    cur = (cur as Record<string, unknown>)[seg]\n  }\n  return cur\n}\n\n/**\n * The civil date a value buckets on. Two paths, and which one a value takes is\n * a property of the VALUE, never of the descriptor (#1410):\n *\n *   - a zoneless calendar string names no instant, so there is nothing to\n *     convert — it is its own civil date, and `key.timeZone` is not applicable\n *     to it. This is what stops `'2026-01-01'` bucketing into 2025 west of UTC;\n *   - anything else IS an instant, and the calendar it falls on is read in\n *     `key.timeZone`, exactly as before.\n *\n * See `civil-date.ts` for which shapes are zoneless and why.\n */\nfunction resolveCivilDate(value: unknown, key: DateTruncKey): { y: number; m: number; d: number } {\n  const civil = civilDateOf(value)\n  if (civil === 'invalid') {\n    throw new Error(\n      `dateTrunc(\"${key.field}\", \"${key.unit}\"): value ${JSON.stringify(value)} is a calendar ` +\n        `date shape but names no real day.`,\n    )\n  }\n  if (civil !== undefined) return civil\n  const ms = toEpochMs(value)\n  if (ms === undefined) {\n    throw new Error(\n      `dateTrunc(\"${key.field}\", \"${key.unit}\"): value ${JSON.stringify(value) ?? typeof value} ` +\n        `is not a timestamp. Expected a Date, epoch milliseconds, or a parseable date string.`,\n    )\n  }\n  return localCivilDate(ms, key.timeZone)\n}\n\nfunction toEpochMs(value: unknown): number | undefined {\n  if (value instanceof Date) return Number.isNaN(value.getTime()) ? undefined : value.getTime()\n  if (typeof value === 'number') return Number.isFinite(value) ? value : undefined\n  if (typeof value === 'string') {\n    const parsed = Date.parse(value)\n    return Number.isNaN(parsed) ? undefined : parsed\n  }\n  return undefined\n}\n\nconst formatters = new Map<string, Intl.DateTimeFormat>()\nfunction formatterFor(timeZone: string): Intl.DateTimeFormat {\n  let f = formatters.get(timeZone)\n  if (!f) {\n    f = new Intl.DateTimeFormat('en-US', {\n      timeZone,\n      year: 'numeric',\n      month: '2-digit',\n      day: '2-digit',\n    })\n    formatters.set(timeZone, f)\n  }\n  return f\n}\n\n/** The civil (wall-clock) calendar date an instant falls on, in `timeZone`. */\nfunction localCivilDate(ms: number, timeZone: string): { y: number; m: number; d: number } {\n  let y = 0\n  let m = 0\n  let d = 0\n  for (const part of formatterFor(timeZone).formatToParts(new Date(ms))) {\n    if (part.type === 'year') y = Number(part.value)\n    else if (part.type === 'month') m = Number(part.value)\n    else if (part.type === 'day') d = Number(part.value)\n  }\n  return { y, m, d }\n}\n\nfunction ymd(y: number, m: number, d: number): string {\n  return `${String(y).padStart(4, '0')}-${String(m).padStart(2, '0')}-${String(d).padStart(2, '0')}`\n}\n\n/** Days since 1970-01-01 for a civil date (Hinnant's algorithm; `m` is 1-12). */\nfunction daysFromCivil(y: number, m: number, d: number): number {\n  const yy = m <= 2 ? y - 1 : y\n  const era = Math.floor(yy / 400)\n  const yoe = yy - era * 400\n  const doy = Math.floor((153 * (m + (m > 2 ? -3 : 9)) + 2) / 5) + d - 1\n  const doe = yoe * 365 + Math.floor(yoe / 4) - Math.floor(yoe / 100) + doy\n  return era * 146097 + doe - 719468\n}\n\n/** Inverse of {@link daysFromCivil}. */\nfunction civilFromDays(z: number): { y: number; m: number; d: number } {\n  const shifted = z + 719468\n  const era = Math.floor(shifted / 146097)\n  const doe = shifted - era * 146097\n  const yoe = Math.floor(\n    (doe - Math.floor(doe / 1460) + Math.floor(doe / 36524) - Math.floor(doe / 146096)) / 365,\n  )\n  const y = yoe + era * 400\n  const doy = doe - (365 * yoe + Math.floor(yoe / 4) - Math.floor(yoe / 100))\n  const mp = Math.floor((5 * doy + 2) / 153)\n  const d = doy - Math.floor((153 * mp + 2) / 5) + 1\n  const m = mp + (mp < 10 ? 3 : -9)\n  return { y: m <= 2 ? y + 1 : y, m, d }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-ANSIZYEG.js → chunk-YNIUIERI.js}

@@ -4,13 +4,13 @@ import {
 import {
   base64ToBuffer,
   bufferToBase64
-} from "./chunk-SL3JAAKN.js";
+} from "./chunk-UYB234ZR.js";
 import {
   SessionExpiredError,
   SessionNotFoundError,
   SessionPolicyError,
   ValidationError
-} from "./chunk-7O3Y4PPD.js";
+} from "./chunk-244VXYPG.js";
 
 // src/with-party/session/session.ts
 var subtle = globalThis.crypto.subtle;
@@ -364,4 +364,4 @@ export {
   clearDevUnlock,
   isDevUnlockActive
 };
-//# sourceMappingURL=chunk-ANSIZYEG.js.map
+//# sourceMappingURL=chunk-YNIUIERI.js.map