@wirecat/mail-cli 0.0.0-stage → 0.1.1

package/dist/bundle/chunk-UH4DDRHA.js

@@ -0,0 +1,2989 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  RegistryError,
+  SNAKE_CASE,
+  STEPS,
+  array,
+  boolean,
+  defineReasons,
+  defineSteps,
+  duplicates,
+  integer,
+  isoTime,
+  lazy,
+  literal,
+  maxValue,
+  minLength,
+  minValue,
+  nullable,
+  number,
+  object,
+  optional,
+  pageSchema,
+  picklist,
+  pipe,
+  reference,
+  safeParse,
+  stepOf,
+  strictObject,
+  string,
+  union,
+  variant
+} from "./chunk-LQ37ALDJ.js";
+import {
+  CliError,
+  isCliError,
+  singleLine,
+  visibleControls
+} from "./chunk-5BVIWP3S.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/reference.js
+var invalid = /* @__PURE__ */ __name(() => new CliError("validation_error", "expected meeting:<accountId>/<meetingId>[/<transcriptId>[/<cuePosition>]] with safe integer IDs"), "invalid");
+var integer2 = /* @__PURE__ */ __name((value, minimum = 1) => {
+  if (!Number.isSafeInteger(value) || value < minimum)
+    throw invalid();
+  return value;
+}, "integer");
+var formatMeetingReference = /* @__PURE__ */ __name((reference2) => {
+  const parts = [integer2(reference2.accountId), integer2(reference2.meetingId)];
+  if (reference2.transcriptId !== void 0)
+    parts.push(integer2(reference2.transcriptId));
+  if (reference2.cuePosition !== void 0) {
+    if (reference2.transcriptId === void 0)
+      throw invalid();
+    parts.push(integer2(reference2.cuePosition, 0));
+  }
+  return `meeting:${parts.join("/")}`;
+}, "formatMeetingReference");
+var parseMeetingReference = /* @__PURE__ */ __name((text6) => {
+  const value = text6.trim();
+  if (!value.startsWith("meeting:"))
+    throw invalid();
+  const parts = value.slice(8).split("/");
+  if (parts.length < 2 || parts.length > 4 || parts.some((part) => !/^\d+$/.test(part)))
+    throw invalid();
+  const ids2 = parts.map(Number);
+  const reference2 = {
+    type: "meeting",
+    accountId: integer2(ids2[0]),
+    meetingId: integer2(ids2[1]),
+    ...ids2.length > 2 ? { transcriptId: integer2(ids2[2]) } : {},
+    ...ids2.length > 3 ? { cuePosition: integer2(ids2[3], 0) } : {}
+  };
+  return reference2;
+}, "parseMeetingReference");
+var canonicalMeetingReference = /* @__PURE__ */ __name((text6) => formatMeetingReference(parseMeetingReference(text6)), "canonicalMeetingReference");
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/query/types.js
+var QUERY_LIMITS = {
+  bytes: 8192,
+  depth: 32,
+  nodes: 256
+};
+var spanSchema = object({ start: number(), end: number() });
+var predicateSchema = object({
+  kind: literal("predicate"),
+  field: string(),
+  operator: picklist(["term", "phrase", "wildcard", "regex", "range"]),
+  value: string(),
+  upper: optional(string()),
+  lower_inclusive: optional(boolean()),
+  upper_inclusive: optional(boolean()),
+  span: spanSchema,
+  implicit: optional(literal(true)),
+  slop: optional(pipe(number(), integer(), minValue(0)))
+});
+var queryNodeSchema = variant("kind", [
+  predicateSchema,
+  object({
+    kind: literal("boolean"),
+    clauses: array(object({ occur: picklist(["must", "should", "must_not"]), node: lazy(() => queryNodeSchema) })),
+    span: spanSchema
+  })
+]);
+var queryAstSchema = object({
+  version: literal(1),
+  language: literal("lucene-v1"),
+  root: queryNodeSchema
+});
+function queryError(reason, span, alternative, context3 = {}, details = {}) {
+  throw new CliError("validation_error", `${context3.command ?? "query"}: ${reason} at position ${span.start + 1}${alternative ? ` \u2014 ${alternative}` : ""}`, {
+    reason,
+    span,
+    ...alternative ? { alternative } : {},
+    ...context3.guide ? { guide: context3.guide } : {},
+    ...details
+  });
+}
+__name(queryError, "queryError");
+var walkQuery = /* @__PURE__ */ __name((node) => node.kind === "predicate" ? [node] : node.clauses.flatMap(({ node: node2 }) => walkQuery(node2)), "walkQuery");
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/query/dates.js
+var timezoneOf = /* @__PURE__ */ __name((given) => {
+  const zone = given ?? Intl.DateTimeFormat().resolvedOptions().timeZone ?? "UTC";
+  try {
+    new Intl.DateTimeFormat("en", { timeZone: zone }).format(0);
+  } catch {
+    queryError("query.invalid-timezone", { start: 0, end: 0 }, "use an IANA timezone such as Europe/Madrid");
+  }
+  return zone;
+}, "timezoneOf");
+var calendar = /* @__PURE__ */ __name((value, span) => {
+  if (!/^\d{4}-\d{2}-\d{2}$/u.test(value))
+    queryError("query.invalid-date", span, "use an ISO date or a quoted timestamp with offset");
+  const year = Number(value.slice(0, 4)), month = Number(value.slice(5, 7)), day = Number(value.slice(8, 10));
+  const date = /* @__PURE__ */ new Date(0);
+  date.setUTCFullYear(year, month - 1, day);
+  date.setUTCHours(0, 0, 0, 0);
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day)
+    queryError("query.invalid-date", span);
+  return date;
+}, "calendar");
+var dayBoundary = /* @__PURE__ */ __name((value, zone, next, span) => {
+  const date = calendar(value, span);
+  if (next)
+    date.setUTCDate(date.getUTCDate() + 1);
+  const wanted = date.getUTCFullYear() * 1e4 + (date.getUTCMonth() + 1) * 100 + date.getUTCDate();
+  const formatter = new Intl.DateTimeFormat("en-CA", {
+    timeZone: zone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    era: "short"
+  });
+  const dayAt = /* @__PURE__ */ __name((time) => {
+    const parts = formatter.formatToParts(time);
+    const value2 = /* @__PURE__ */ __name((name) => Number(parts.find((p) => p.type === name)?.value), "value");
+    const year = parts.find((p) => p.type === "era")?.value === "BC" ? 1 - value2("year") : value2("year");
+    return year * 1e4 + value2("month") * 100 + value2("day");
+  }, "dayAt");
+  let lo = date.getTime() - 2 * 864e5, hi = date.getTime() + 2 * 864e5;
+  while (lo < hi) {
+    const mid = Math.floor((lo + hi) / 2);
+    if (dayAt(mid) < wanted)
+      lo = mid + 1;
+    else
+      hi = mid;
+  }
+  if (dayAt(lo) !== wanted)
+    queryError("query.invalid-date", span, "this calendar day does not exist in the selected timezone");
+  return lo;
+}, "dayBoundary");
+var WALL = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?$/u;
+var wallTime = /* @__PURE__ */ __name((value, zone, span) => {
+  const [, year, month, day, hour, minute, second = "0", fraction = "0"] = WALL.exec(value) ?? [];
+  if (year === void 0)
+    queryError("query.invalid-date", span, "use YYYY-MM-DDTHH:mm, with optional seconds");
+  const wanted = Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second), Number(fraction.padEnd(3, "0")));
+  const check = new Date(wanted);
+  if (check.getUTCDate() !== Number(day) || check.getUTCHours() !== Number(hour) || check.getUTCMinutes() !== Number(minute) || check.getUTCSeconds() !== Number(second))
+    queryError("query.invalid-date", span);
+  const formatter = new Intl.DateTimeFormat("en-CA", {
+    timeZone: zone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hourCycle: "h23"
+  });
+  const shown = /* @__PURE__ */ __name((instant) => {
+    const parts = Object.fromEntries(formatter.formatToParts(instant).map((part) => [part.type, Number(part.value)]));
+    return Date.UTC(parts.year ?? 0, (parts.month ?? 1) - 1, parts.day, parts.hour, parts.minute, parts.second) + (instant % 1e3 + 1e3) % 1e3;
+  }, "shown");
+  const found = /* @__PURE__ */ new Set();
+  for (const probe of [wanted - 864e5, wanted, wanted + 864e5]) {
+    const candidate = wanted - (shown(probe) - probe);
+    if (shown(candidate) === wanted)
+      found.add(candidate);
+  }
+  if (found.size !== 1)
+    queryError("query.invalid-date", span, "this local time is skipped or repeated by daylight saving; add an offset");
+  return [...found][0];
+}, "wallTime");
+var ZONED = /(?:Z|[+-]\d{2}:?\d{2})$/iu;
+var zonedMoment = /* @__PURE__ */ __name((value, zone, span, { end = false } = {}) => {
+  if (/^\d{4}-\d{2}-\d{2}$/u.test(value))
+    return dayBoundary(value, zone, end, span) - (end ? 1 : 0);
+  if (!ZONED.test(value))
+    return wallTime(value, zone, span);
+  const time = Date.parse(value);
+  if (!/^\d{4}-\d{2}-\d{2}T/u.test(value) || !Number.isFinite(time))
+    queryError("query.invalid-date", span);
+  calendar(value.slice(0, 10), span);
+  return time;
+}, "zonedMoment");
+var AGO = /^(\d+)(m|h|d)$/u;
+var AGO_MS = { m: 6e4, h: 36e5, d: 864e5 };
+var dayOf = /* @__PURE__ */ __name((word, zone, now, span) => {
+  const today = new Intl.DateTimeFormat("en-CA", {
+    timeZone: zone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).format(now);
+  if (word === "today")
+    return today;
+  const date = calendar(today, span);
+  date.setUTCDate(date.getUTCDate() - 1);
+  return date.toISOString().slice(0, 10);
+}, "dayOf");
+var dateEndpoint = /* @__PURE__ */ __name((value, zone, side, inclusive, span, now = Date.now()) => {
+  if (value === "*")
+    return { inclusive };
+  const word = value.toLowerCase();
+  if (word === "today" || word === "yesterday")
+    return dateEndpoint(dayOf(word, zone, now, span), zone, side, inclusive, span);
+  const [, amount, unit] = AGO.exec(word) ?? [];
+  if (amount && unit)
+    return { time: now - Number(amount) * (AGO_MS[unit] ?? 0), inclusive };
+  if (/^\d{4}-\d{2}-\d{2}$/u.test(value))
+    return {
+      time: dayBoundary(value, zone, side === "lower" ? !inclusive : inclusive, span),
+      inclusive: side === "lower"
+    };
+  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/u.test(value))
+    queryError("query.invalid-date", span, "use an ISO date, today, yesterday, 30m/2h/7d ago, or a quoted timestamp with offset");
+  calendar(value.slice(0, 10), span);
+  const time = Date.parse(value);
+  if (!Number.isFinite(time) || Number(value.slice(11, 13)) > 23 || Number(value.slice(14, 16)) > 59 || Number(value.slice(17, 19)) > 59)
+    queryError("query.invalid-date", span);
+  return { time, inclusive };
+}, "dateEndpoint");
+var dateRange = /* @__PURE__ */ __name((lower, upper, lowerInclusive, upperInclusive, zone, span, now = Date.now()) => {
+  const since = lower === upper && AGO.test(lower.toLowerCase());
+  const lo = dateEndpoint(lower, zone, "lower", lowerInclusive, span, now);
+  const hi = dateEndpoint(since ? "*" : upper, zone, "upper", upperInclusive, span, now);
+  return {
+    ...lo.time === void 0 ? {} : { lower: lo.time },
+    ...hi.time === void 0 ? {} : { upper: hi.time },
+    lower_inclusive: lo.inclusive,
+    upper_inclusive: hi.inclusive
+  };
+}, "dateRange");
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/query/evaluate.js
+var wordsOf = /* @__PURE__ */ __name((text6) => text6.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [], "wordsOf");
+var pattern = /* @__PURE__ */ __name((value) => new RegExp(`^${[...value].map((char) => char === "*" ? ".*" : char === "?" ? "." : char.replace(/[.+^${}()|[\]\\]/, "\\$&")).join("")}$`, "iu"), "pattern");
+var present = /* @__PURE__ */ __name((value) => value !== void 0 && value !== null && value !== "", "present");
+var matchOne = /* @__PURE__ */ __name((field, node, value, options) => {
+  if (!present(value))
+    return false;
+  if (node.operator === "wildcard" && node.value === "*")
+    return true;
+  const text6 = String(value);
+  switch (field.type) {
+    case "txt": {
+      const words2 = wordsOf(text6);
+      if (node.operator === "wildcard")
+        return words2.some((word) => pattern(node.value).test(word));
+      const wanted = wordsOf(node.value);
+      return words2.some((_, at) => wanted.every((word, offset) => words2[at + offset] === word));
+    }
+    case "num": {
+      const number2 = Number(value);
+      if (node.operator !== "range")
+        return number2 === Number(node.value);
+      const { value: lower, upper = "*", lower_inclusive: lowerInclusive, upper_inclusive: upperInclusive } = node;
+      return (lower === "*" || (lowerInclusive ? number2 >= Number(lower) : number2 > Number(lower))) && (upper === "*" || (upperInclusive ? number2 <= Number(upper) : number2 < Number(upper)));
+    }
+    case "time": {
+      const time = Date.parse(text6);
+      const [lower, upper, lowerInclusive, upperInclusive] = node.operator === "range" ? [node.value, node.upper ?? "*", node.lower_inclusive ?? true, node.upper_inclusive ?? true] : [node.value, node.value, true, true];
+      const range = dateRange(lower, upper, lowerInclusive, upperInclusive, options.zone ?? "UTC", node.span, options.now);
+      return (range.lower === void 0 || (range.lower_inclusive ? time >= range.lower : time > range.lower)) && (range.upper === void 0 || (range.upper_inclusive ? time <= range.upper : time < range.upper));
+    }
+    default:
+      return node.operator === "wildcard" ? pattern(node.value).test(text6) : text6.toLowerCase() === node.value.toLowerCase();
+  }
+}, "matchOne");
+var matches = /* @__PURE__ */ __name((node, item, byName, options) => {
+  if (node.kind === "boolean") {
+    const by = /* @__PURE__ */ __name((occur) => node.clauses.filter((clause) => clause.occur === occur), "by");
+    const [must, should, mustNot] = [by("must"), by("should"), by("must_not")];
+    const holds = /* @__PURE__ */ __name((clause) => matches(clause.node, item, byName, options), "holds");
+    return must.every(holds) && !mustNot.some(holds) && (should.length === 0 || must.length > 0 || should.some(holds));
+  }
+  const field = byName.get(node.field);
+  if (!field)
+    throw new Error(`evaluate: no field "${node.field}"; validate the query first`);
+  if (field.relation !== void 0) {
+    if (!options.relation)
+      throw new Error(`evaluate: "${node.field}" is a relation; pass options.relation`);
+    return options.relation(node, item);
+  }
+  const value = item[node.field];
+  return Array.isArray(value) ? value.some((one) => matchOne(field, node, one, options)) : matchOne(field, node, value, options);
+}, "matches");
+var evaluate = /* @__PURE__ */ __name((ast, fields2, item, options = {}) => matches(ast.root, item, new Map(fields2.map((field) => [field.name, field])), options), "evaluate");
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/query/fields.js
+var FIELD_TYPES = ["kw", "txt", "enum", "num", "time", "bool", "ref"];
+var OPERATORS_BY_TYPE = {
+  kw: ["term", "phrase", "wildcard"],
+  txt: ["term", "phrase", "wildcard"],
+  enum: ["term"],
+  num: ["term", "range"],
+  time: ["term", "range"],
+  bool: ["term"],
+  ref: ["term", "phrase"]
+};
+var QUERY_BACKENDS = ["sql", "native"];
+var unwrap = /* @__PURE__ */ __name((schema) => schema.wrapped ? unwrap(schema.wrapped) : schema, "unwrap");
+var REFERENCE_SOURCE = reference.pipe[1].requirement.source;
+var typeOf = /* @__PURE__ */ __name((schema) => {
+  const plain = unwrap(schema);
+  const actions = plain.pipe ?? [];
+  switch (plain.type) {
+    case "picklist":
+      return { type: "enum", values: (plain.options ?? []).map(String) };
+    case "number":
+      return { type: "num" };
+    case "boolean":
+      return { type: "bool" };
+    case "string":
+      if (actions.some((action) => action.type === "iso_timestamp"))
+        return { type: "time" };
+      if (actions.some((action) => action.requirement instanceof RegExp && action.requirement.source === REFERENCE_SOURCE))
+        return { type: "ref" };
+      return { type: "kw" };
+    case "array":
+      return plain.item ? typeOf(plain.item) : void 0;
+    default:
+      return void 0;
+  }
+}, "typeOf");
+var exampleOf = /* @__PURE__ */ __name((name, type, values) => ({
+  kw: `${name}:abc`,
+  txt: `${name}:word*`,
+  enum: `${name}:${values?.[0] ?? "x"}`,
+  num: `${name}>0`,
+  time: `${name}>=7d`,
+  bool: `${name}:true`,
+  ref: `${name}:"note:42"`
+})[type], "exampleOf");
+var queryFieldsOf = /* @__PURE__ */ __name((schema, annotations = {}) => {
+  const entries = unwrap(schema).entries ?? {};
+  const excluded = new Set(annotations.exclude ?? []);
+  const words2 = new Set(annotations.text ?? []);
+  const native = new Set(annotations.native ?? []);
+  const finish = /* @__PURE__ */ __name((field) => ({
+    ...field,
+    operators: OPERATORS_BY_TYPE[field.type],
+    example: annotations.examples?.[field.name] ?? field.example ?? exampleOf(field.name, field.type, field.values),
+    ...native.has(field.name) ? { native: true } : {},
+    ...annotations.validate?.[field.name] ? { validate: annotations.validate[field.name] } : {}
+  }), "finish");
+  const own = Object.entries(entries).flatMap(([name, entry]) => {
+    if (excluded.has(name))
+      return [];
+    const found = typeOf(entry);
+    if (!found)
+      return [];
+    return [finish({ name, ...found, ...words2.has(name) && found.type === "kw" ? { type: "txt" } : {} })];
+  });
+  const relations = Object.entries(annotations.relations ?? {}).map(([name, relation]) => finish({ name, ...relation }));
+  const states = annotations.states ? [
+    finish({
+      name: "is",
+      type: "enum",
+      values: Object.keys(annotations.states),
+      relation: Object.entries(annotations.states).map(([state, meaning]) => `${state}: ${meaning}`).join("; ")
+    })
+  ] : [];
+  return [...own, ...relations, ...states];
+}, "queryFieldsOf");
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/query/help.js
+var QUERY_SYNTAX = 'field:value \xB7 "a phrase" \xB7 word* \xB7 AND OR NOT \xB7 ( ) \xB7 [a TO b] \xB7 > >= < <=';
+var kindOf = /* @__PURE__ */ __name((field) => field.values ? `${field.type}: ${field.values.join("|")}` : `${field.type}: ${field.operators.join(", ")}`, "kindOf");
+var fieldsHelp = /* @__PURE__ */ __name((registry, guide) => {
+  const shown = registry.backend === "native" ? registry.fields.filter((field) => field.native) : registry.fields;
+  const rows = shown.map((field) => [field.name, kindOf(field), field.example]);
+  const widths = [0, 1].map((at) => Math.max(...rows.map((row) => (row[at] ?? "").length)));
+  return [
+    "Fields:",
+    ...rows.map(([name = "", kind = "", example = ""]) => `  ${name.padEnd(widths[0] ?? 0)}  ${kind.padEnd(widths[1] ?? 0)}  ${example}`.trimEnd()),
+    ...registry.defaults && registry.defaults.length > 0 ? [`Defaults: ${registry.defaults.join(" ")} \u2014 name the field to change it`] : [],
+    `Syntax: ${QUERY_SYNTAX}`,
+    ...guide ? [`Guide: ${guide}`] : []
+  ].join("\n");
+}, "fieldsHelp");
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/query/parser.js
+var whitespace = /* @__PURE__ */ __name((c) => /[ \t\n\r\u3000]/u.test(c), "whitespace");
+var reserved = /* @__PURE__ */ new Set([
+  "+",
+  "-",
+  "!",
+  "(",
+  ")",
+  ":",
+  "=",
+  "^",
+  "@",
+  "<",
+  ">",
+  "[",
+  "]",
+  '"',
+  "{",
+  "}",
+  "~",
+  "\\",
+  "/"
+]);
+var decodeEscapes = /* @__PURE__ */ __name((raw, span, fail) => {
+  let out = "";
+  for (let at = 0; at < raw.length; at++) {
+    if (raw[at] !== "\\") {
+      out += raw[at];
+      continue;
+    }
+    if (++at >= raw.length)
+      fail("query.invalid-escape", span);
+    if (raw[at] === "u") {
+      const hex = raw.slice(at + 1, at + 5);
+      if (!/^[0-9a-fA-F]{4}$/.test(hex))
+        fail("query.invalid-escape", span);
+      out += String.fromCharCode(Number.parseInt(hex, 16));
+      at += 4;
+    } else
+      out += raw[at];
+  }
+  return out;
+}, "decodeEscapes");
+var tokensOf = /* @__PURE__ */ __name((text6, fail = queryError) => {
+  const tokens = [];
+  let at = 0;
+  let range = false;
+  while (at < text6.length) {
+    const start = at;
+    const c = text6[at] ?? "";
+    if (whitespace(c)) {
+      at++;
+      continue;
+    }
+    let kind = c;
+    if (c === '"' || !range && c === "/") {
+      at++;
+      while (at < text6.length && text6[at] !== c) {
+        if (text6[at] === "\\" && (c === '"' || text6[at + 1] === "/"))
+          at++;
+        at++;
+      }
+      if (at >= text6.length)
+        fail("query.unclosed-literal", { start, end: at }, c === "/" ? regexHint(text6, start) : void 0);
+      at++;
+      if (c === "/" && /^[dgimsuvy]+(?:$|[ \t\n\r)])/.test(text6.slice(at)))
+        fail("query.unsupported-regex-flags", { start: at, end: at + 1 }, "Lucene regex does not take JavaScript flags");
+      kind = c === '"' ? "quoted" : "regex";
+    } else if (range && c !== "]" && c !== "}") {
+      while (at < text6.length && !whitespace(text6[at] ?? "") && !["]", "}"].includes(text6[at] ?? ""))
+        at++;
+      kind = "rangeValue";
+    } else if (reserved.has(c)) {
+      if (c === "\\") {
+        at += 2;
+        while (at < text6.length && !whitespace(text6[at] ?? "") && (!reserved.has(text6[at] ?? "") || ["+", "-"].includes(text6[at] ?? "")))
+          at++;
+        kind = "term";
+      } else {
+        at++;
+        if ((c === "<" || c === ">") && text6[at] === "=") {
+          at++;
+          kind += "=";
+        }
+        if (c === "[" || c === "{")
+          range = true;
+        if (c === "]" || c === "}")
+          range = false;
+      }
+    } else {
+      at++;
+      while (at < text6.length) {
+        const next = text6[at] ?? "";
+        if (next === "\\") {
+          if (at + 1 >= text6.length)
+            fail("query.invalid-escape", { start: at, end: at + 1 });
+          at += 2;
+          continue;
+        }
+        if (next === "@" && new RegExp("^@(?:\\p{L}|[\\p{L}\\p{N}][^\\s@]*\\.[\\p{L}\\p{N}])", "u").test(text6.slice(at))) {
+          at++;
+          continue;
+        }
+        if (whitespace(next) || reserved.has(next) && next !== "+" && next !== "-")
+          break;
+        at++;
+      }
+      const raw = text6.slice(start, at);
+      kind = { AND: "AND", OR: "OR", NOT: "NOT", "&&": "AND", "||": "OR" }[raw] ?? (/^\d+(?:\.\d+)?$/u.test(raw) ? "number" : "term");
+    }
+    tokens.push({ kind, raw: text6.slice(start, at), span: { start, end: at } });
+  }
+  tokens.push({ kind: "EOF", raw: "", span: { start: at, end: at } });
+  return tokens;
+}, "tokensOf");
+var quoteHint = /* @__PURE__ */ __name((text6, at) => {
+  for (const match of text6.matchAll(/(?<=^|[\s(])([\p{L}\p{N}_.-]+):([^\s"()]+)/gu)) {
+    const [whole, field, value = ""] = match;
+    if (at < match.index || at > match.index + whole.length)
+      continue;
+    return /[:=/?*~^@<>![\]{}\\]/u.test(value) ? `put the value in quotes: ${field}:"${value}"` : void 0;
+  }
+  return void 0;
+}, "quoteHint");
+var regexHint = /* @__PURE__ */ __name((text6, at) => {
+  const word = `${/[^\s()"]*$/u.exec(text6.slice(0, at))?.[0] ?? ""}${/^[^\s()"]*/u.exec(text6.slice(at))?.[0] ?? ""}`;
+  return quoteHint(text6, at) ?? `/ starts a regular expression; put the value in quotes: "${word}"`;
+}, "regexHint");
+var parseLucene = /* @__PURE__ */ __name((text6, { defaultField = "text", proximity = false, ...context3 } = {}) => {
+  const fail = /* @__PURE__ */ __name((reason, span, alternative) => queryError(reason, span, alternative ?? quoteHint(text6, span.start), context3), "fail");
+  if (text6.length > QUERY_LIMITS.bytes || new TextEncoder().encode(text6).length > QUERY_LIMITS.bytes)
+    fail("query.too-large", { start: 0, end: text6.length });
+  const tokens = tokensOf(text6, fail);
+  let at = 0;
+  let count6 = 0;
+  let depth = 0;
+  const peek = /* @__PURE__ */ __name(() => tokens[at], "peek");
+  const take = /* @__PURE__ */ __name(() => tokens[at++], "take");
+  const expect = /* @__PURE__ */ __name((kind) => {
+    if (peek().kind !== kind)
+      fail("query.invalid-syntax", peek().span);
+    return take();
+  }, "expect");
+  const built = /* @__PURE__ */ __name((node) => {
+    if (++count6 > QUERY_LIMITS.nodes)
+      fail("query.too-large", node.span);
+    return node;
+  }, "built");
+  const combine = /* @__PURE__ */ __name((clauses, occur) => {
+    const first = clauses[0];
+    const last = clauses.at(-1);
+    if (!first || !last)
+      fail("query.invalid-syntax", peek().span);
+    if (clauses.length === 1)
+      return first;
+    return {
+      node: built({
+        kind: "boolean",
+        clauses: clauses.map(({ node, modifier }) => ({ node, occur: modifier ?? occur })),
+        span: { start: first.node.span.start, end: last.node.span.end }
+      })
+    };
+  }, "combine");
+  const query = /* @__PURE__ */ __name((field, implicit = false) => {
+    if (++depth > QUERY_LIMITS.depth)
+      fail("query.too-large", peek().span);
+    const clauses = [];
+    do {
+      clauses.push(disjunction(field, implicit));
+    } while (!["EOF", ")"].includes(peek().kind));
+    const result = combine(clauses, "must");
+    depth--;
+    if (result.modifier === "must_not")
+      return built({ kind: "boolean", clauses: [{ node: result.node, occur: "must_not" }], span: result.node.span });
+    return result.node;
+  }, "query");
+  const disjunction = /* @__PURE__ */ __name((field, implicit) => {
+    const clauses = [conjunction(field, implicit)];
+    while (peek().kind === "OR") {
+      take();
+      clauses.push(conjunction(field, implicit));
+    }
+    return combine(clauses, "should");
+  }, "disjunction");
+  const conjunction = /* @__PURE__ */ __name((field, implicit) => {
+    const clauses = [clause(field, implicit)];
+    while (peek().kind === "AND") {
+      take();
+      clauses.push(clause(field, implicit));
+    }
+    return combine(clauses, "must");
+  }, "conjunction");
+  const clause = /* @__PURE__ */ __name((inherited, inheritedImplicit) => {
+    let modifier;
+    if (["+", "-", "NOT", "!"].includes(peek().kind))
+      modifier = take().kind === "+" ? "must" : "must_not";
+    let field = inherited;
+    let start;
+    let implicit = inheritedImplicit;
+    if (peek().kind === "term" && [":", "=", "<", ">", "<=", ">="].includes(tokens[at + 1]?.kind ?? "")) {
+      const token = take();
+      field = decodeEscapes(token.raw, token.span, fail);
+      start = token.span.start;
+      implicit = false;
+      let operator = take();
+      if (operator.kind === ":" && ["<", ">", "<=", ">="].includes(peek().kind))
+        operator = take();
+      if (["<", ">", "<=", ">="].includes(operator.kind)) {
+        const value = take();
+        if (!["term", "number", "quoted"].includes(value.kind))
+          fail("query.invalid-syntax", value.span);
+        const decoded = decodeEscapes(value.kind === "quoted" ? value.raw.slice(1, -1) : value.raw, value.span, fail);
+        const lower = operator.kind.startsWith(">");
+        const node2 = built({
+          kind: "predicate",
+          field,
+          operator: "range",
+          value: lower ? decoded : "*",
+          upper: lower ? "*" : decoded,
+          lower_inclusive: !lower || operator.kind.endsWith("="),
+          upper_inclusive: lower || operator.kind.endsWith("="),
+          span: { start: token.span.start, end: value.span.end }
+        });
+        return { node: node2, ...modifier ? { modifier } : {} };
+      }
+    }
+    let node;
+    if (peek().kind === "(") {
+      const start2 = take().span.start;
+      node = query(field, implicit);
+      const end = expect(")").span.end;
+      node = { ...node, span: { start: start2, end } };
+    } else if (["[", "{"].includes(peek().kind)) {
+      const opening = take();
+      const lower = take();
+      if (!["rangeValue", "quoted"].includes(lower.kind))
+        fail("query.invalid-syntax", lower.span);
+      const separator = take();
+      if (separator.raw !== "TO")
+        fail("query.invalid-syntax", separator.span);
+      const upper = take();
+      if (!["rangeValue", "quoted"].includes(upper.kind))
+        fail("query.invalid-syntax", upper.span);
+      const closing = take();
+      if (!["]", "}"].includes(closing.kind))
+        fail("query.invalid-syntax", closing.span);
+      const decode = /* @__PURE__ */ __name((t) => decodeEscapes(t.kind === "quoted" ? t.raw.slice(1, -1) : t.raw, t.span, fail), "decode");
+      node = built({
+        kind: "predicate",
+        field,
+        operator: "range",
+        value: decode(lower),
+        upper: decode(upper),
+        lower_inclusive: opening.kind === "[",
+        upper_inclusive: closing.kind === "]",
+        span: { start: start ?? opening.span.start, end: closing.span.end }
+      });
+    } else {
+      const token = take();
+      if (!["term", "number", "quoted", "regex"].includes(token.kind))
+        fail("query.invalid-syntax", token.span);
+      const raw = ["term", "number"].includes(token.kind) ? token.raw : token.raw.slice(1, -1);
+      if (field === "fn")
+        fail("query.unsupported-operator", token.span, "interval functions are not supported");
+      const wildcard = ["term", "number"].includes(token.kind) && /(?<!\\)[*?]/u.test(raw);
+      node = built({
+        kind: "predicate",
+        field,
+        operator: token.kind === "regex" ? "regex" : token.kind === "quoted" ? "phrase" : wildcard ? "wildcard" : "term",
+        value: token.kind === "regex" || wildcard ? raw : decodeEscapes(raw, token.span, fail),
+        span: { start: start ?? token.span.start, end: token.span.end },
+        ...implicit ? { implicit: true } : {}
+      });
+    }
+    if (proximity && peek().kind === "~" && node.kind === "predicate" && node.operator === "phrase") {
+      take();
+      const distance = take();
+      if (distance.kind !== "number" || !/^\d+$/u.test(distance.raw))
+        fail("query.invalid-syntax", distance.span, 'write the distance as a whole number: "a b"~3');
+      node = { ...node, slop: Number(distance.raw), span: { start: node.span.start, end: distance.span.end } };
+    }
+    if (peek().kind === "~")
+      fail("query.unsupported-operator", peek().span, node.kind === "predicate" && node.operator === "phrase" ? "proximity (~) is not supported \u2014 drop the ~ for the exact phrase, or join the words with AND" : "fuzzy matching (~) is not supported \u2014 use a prefix such as word* to catch word forms");
+    if (["^", "@"].includes(peek().kind))
+      fail("query.unsupported-operator", peek().span, "boost and minimum-should-match are not supported");
+    return { node, ...modifier ? { modifier } : {} };
+  }, "clause");
+  const root = query(defaultField, true);
+  expect("EOF");
+  if (defaultField === "none") {
+    const bare = walkQuery(root).find((node) => node.implicit);
+    if (bare)
+      queryError("query.bare-word", bare.span, `"${bare.value}" has no field; write field:value`, context3, {
+        word: bare.value
+      });
+  }
+  return { version: 1, language: "lucene-v1", root };
+}, "parseLucene");
+var implicitTextTerms = /* @__PURE__ */ __name((text6) => {
+  const tokens = tokensOf(text6);
+  if (tokens.some(({ kind }) => ["AND", "OR", "NOT", "+", "-", "!", "(", ")"].includes(kind)))
+    return /* @__PURE__ */ new Set();
+  return new Set(tokens.flatMap((token, index) => (token.kind === "term" || token.kind === "number") && ![":", "=", "<", ">", "<=", ">="].includes(tokens[index - 1]?.kind ?? "") && ![":", "=", "<", ">", "<=", ">="].includes(tokens[index + 1]?.kind ?? "") ? [token.span.start] : []));
+}, "implicitTextTerms");
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/query/validate.js
+var inContext = /* @__PURE__ */ __name((context3, run2) => {
+  try {
+    run2();
+  } catch (failure) {
+    if (!isCliError(failure) || typeof failure.details.reason !== "string" || failure.details.span === void 0)
+      throw failure;
+    const { reason, span, alternative } = failure.details;
+    queryError(reason, span, alternative, context3);
+  }
+}, "inContext");
+var bounds = /* @__PURE__ */ __name((node) => node.operator === "range" ? [node.value, node.upper ?? "*"].filter((bound) => bound !== "*") : [node.value], "bounds");
+var checkValue = /* @__PURE__ */ __name((field, node, options) => {
+  const fail = /* @__PURE__ */ __name((reason, alternative) => queryError(reason, node.span, alternative, options), "fail");
+  if (node.value === "" && field.type !== "txt")
+    fail("query.missing-value");
+  if (node.operator === "wildcard")
+    return;
+  switch (field.type) {
+    case "enum":
+      if (!field.values?.includes(node.value.toLowerCase()))
+        fail("query.unknown-value", `${field.name} takes ${field.values?.join(", ")}`);
+      return;
+    case "bool":
+      if (!["true", "false"].includes(node.value.toLowerCase()))
+        fail("query.unknown-value", `${field.name} takes true, false`);
+      return;
+    case "num":
+      for (const bound of bounds(node))
+        if (!Number.isFinite(Number(bound)) || bound.trim() === "")
+          fail("query.invalid-number", `${field.name} takes a number`);
+      return;
+    case "time":
+      inContext(options, () => {
+        for (const bound of bounds(node))
+          dateEndpoint(bound, options.zone ?? "UTC", "lower", true, node.span);
+      });
+      return;
+    default:
+      return;
+  }
+}, "checkValue");
+var validateQuery = /* @__PURE__ */ __name((ast, registry, options = {}) => {
+  const byName = new Map(registry.fields.map((field) => [field.name, field]));
+  const visit = /* @__PURE__ */ __name((node, required) => {
+    if (node.kind === "boolean") {
+      for (const clause of node.clauses)
+        visit(clause.node, required && clause.occur === "must");
+      return;
+    }
+    const field = byName.get(node.field);
+    if (!field)
+      queryError("query.unknown-field", node.span, `no field "${node.field}"`, options, {
+        fields: registry.fields.map((one) => one.name)
+      });
+    if (registry.backend === "native" && !field.native)
+      queryError("query.unsupported-field", node.span, `the source cannot filter by ${field.name}`, options, {
+        supported: registry.fields.filter((one) => one.native).map((one) => one.name)
+      });
+    const presence = node.operator === "wildcard" && node.value === "*";
+    if (!presence && !field.operators.includes(node.operator))
+      queryError("query.unsupported-operator", node.span, `${field.name} takes ${field.operators.join(", ")}`, options);
+    if (field.placement === "and" && !required)
+      queryError("query.unsupported-placement", node.span, `${field.name} only as a required term, not under OR or NOT`, options);
+    if (presence)
+      return;
+    checkValue(field, node, options);
+    if (field.validate)
+      inContext(options, () => field.validate?.(node));
+  }, "visit");
+  visit(ast.root, true);
+  return ast;
+}, "validateQuery");
+var fieldsNamed = /* @__PURE__ */ __name((ast) => new Set(walkQuery(ast.root).map((node) => node.field)), "fieldsNamed");
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/query/registry.js
+var describeQuery = /* @__PURE__ */ __name((registry) => ({
+  entity: registry.entity,
+  backend: registry.backend,
+  fields: registry.fields.map(({ validate: _, ...field }) => field),
+  ...registry.defaults && registry.defaults.length > 0 ? { defaults: [...registry.defaults] } : {}
+}), "describeQuery");
+var exampleProblems = /* @__PURE__ */ __name((registry) => {
+  const syntaxOnly = { ...registry, backend: "sql" };
+  const problem = /* @__PURE__ */ __name((text6, field) => {
+    try {
+      const named = walkQuery(validateQuery(parseLucene(text6, { defaultField: "none" }), syntaxOnly).root);
+      return named.every((node) => node.field === field) ? void 0 : `"${text6}" does not name ${field}`;
+    } catch (failure) {
+      if (!isCliError(failure))
+        throw failure;
+      return `"${text6}": ${failure.message}`;
+    }
+  }, "problem");
+  const defaults = (registry.defaults ?? []).map((term) => {
+    const field = term.replace(/^-/, "").split(/[:<>=]/)[0] ?? "";
+    return { field, problem: problem(term.replace(/^-/, ""), field) };
+  });
+  return [
+    ...registry.fields.map((field) => ({ field: field.name, problem: problem(field.example, field.name) })),
+    ...defaults
+  ].filter((entry) => entry.problem !== void 0);
+}, "exampleProblems");
+var checked = /* @__PURE__ */ new WeakSet();
+var defineQuery = /* @__PURE__ */ __name((registry) => {
+  if (checked.has(registry))
+    return registry;
+  const names = registry.fields.map((field) => field.name);
+  const problems = [
+    ...duplicates(names).map((name) => `"${name}" is listed twice`),
+    ...names.filter((name) => !SNAKE_CASE.test(name)).map((name) => `"${name}" is not snake_case`),
+    ...exampleProblems(registry).map(({ field, problem }) => `${field}: ${problem}`)
+  ];
+  if (problems.length > 0)
+    throw new RegistryError(`${registry.entity} query`, problems);
+  checked.add(registry);
+  return registry;
+}, "defineQuery");
+var SPAN = ["span", "alternative", "guide"];
+var QUERY_REASONS = defineReasons([
+  ["query.bare-word", "a word in the query has no field", ["word"]],
+  ["query.invalid-ast", "the query tree is not valid", []],
+  ["query.invalid-date", "a date in the query cannot be read", []],
+  ["query.invalid-escape", "an escape in the query is not valid", []],
+  ["query.invalid-number", "a number in the query cannot be read", []],
+  ["query.invalid-regex", "a regular expression in the query is not valid", []],
+  ["query.invalid-syntax", "the query cannot be parsed", []],
+  ["query.invalid-timezone", "the time zone is not known", []],
+  ["query.missing-value", "a field in the query has no value", []],
+  ["query.too-large", "the query is over one of its limits", []],
+  ["query.unclosed-literal", "a quote or bracket in the query is not closed", []],
+  ["query.unknown-field", "a field in the query is not known", ["fields"]],
+  ["query.unknown-value", "a value in the query is not known", []],
+  ["query.unsupported-field", "this list cannot filter by that field", ["supported"]],
+  ["query.unsupported-operator", "this field does not take that operator", []],
+  ["query.unsupported-placement", "this field works only as a required term", []],
+  ["query.unsupported-regex", "that regular expression is not supported", []],
+  ["query.unsupported-regex-flags", "regular expression flags are not supported", []],
+  ["query.unsupported-version", "the query version is not supported", []]
+].map(([reason, message, details]) => ({
+  reason,
+  code: "validation_error",
+  message,
+  details: [...SPAN, ...details]
+})));
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/item.js
+var text = string();
+var count = pipe(number(), integer(), minValue(0));
+var MEETING_ISSUES = ["time_without_zone"];
+var meetingIssuesOf = /* @__PURE__ */ __name((metadata) => {
+  const listed2 = metadata?.issues;
+  return Array.isArray(listed2) ? MEETING_ISSUES.filter((issue) => listed2.includes(issue)) : [];
+}, "meetingIssuesOf");
+var meeting = strictObject({
+  ref: reference,
+  id: pipe(string(), minLength(1)),
+  provider: text,
+  account: text,
+  title: nullable(text),
+  description: optional(nullable(text)),
+  location: optional(nullable(text)),
+  /** The link that joins it. */
+  url: nullable(text),
+  started_at: nullable(isoTime),
+  ended_at: nullable(isoTime),
+  duration_ms: nullable(count),
+  timezone: optional(nullable(text)),
+  participants_count: nullable(count),
+  /** Present only when something about this meeting is doubtful. */
+  issues: optional(array(picklist(MEETING_ISSUES))),
+  created_at: isoTime,
+  updated_at: isoTime
+});
+var iso = /* @__PURE__ */ __name((ms) => ms === null ? null : new Date(ms).toISOString(), "iso");
+var meetingItem = /* @__PURE__ */ __name((row, owner) => {
+  const issues = meetingIssuesOf(row.metadata);
+  return {
+    ref: formatMeetingReference({ type: "meeting", accountId: row.accountId, meetingId: row.id }),
+    id: String(row.id),
+    provider: owner.provider,
+    account: owner.account,
+    title: row.title,
+    description: row.description,
+    location: row.location,
+    url: row.joinUrl,
+    started_at: iso(row.startedAt),
+    ended_at: iso(row.endedAt),
+    duration_ms: row.durationMs,
+    timezone: row.timezone,
+    participants_count: row.participantsCount,
+    ...issues.length ? { issues } : {},
+    created_at: new Date(row.createdAt).toISOString(),
+    updated_at: new Date(row.updatedAt).toISOString()
+  };
+}, "meetingItem");
+var MEETING_QUERY = {
+  entity: "meeting",
+  backend: "sql",
+  fields: queryFieldsOf(meeting, {
+    exclude: ["ref", "provider", "account", "description", "location", "url", "timezone", "issues"],
+    examples: {
+      id: "id:12",
+      title: "title:*standup*",
+      started_at: "started_at:[2026-10-01 TO 2026-10-31]",
+      duration_ms: "duration_ms>=3600000",
+      participants_count: "participants_count>5"
+    }
+  })
+};
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/answers.js
+var text2 = string();
+var count2 = pipe(number(), integer(), minValue(0));
+var iso2 = /* @__PURE__ */ __name((ms) => ms === null ? null : new Date(ms).toISOString(), "iso");
+var meetingHit = strictObject({
+  /** The cue for a transcript passage, else the meeting. */
+  ref: reference,
+  meeting: reference,
+  scope: picklist(["transcript", "chat", "summary"]),
+  /** The stored line, so two passages of one meeting stay apart. */
+  id: pipe(string(), minLength(1)),
+  excerpt: text2,
+  /** How far into the meeting the passage is. */
+  offset_ms: nullable(count2),
+  /** `corrected`: a query word matched only a garbled form of itself, listed in `corrections`. */
+  match: optional(picklist(["words", "corrected"])),
+  corrections: optional(array(strictObject({ from: text2, to: array(text2) }))),
+  source: optional(strictObject({
+    ref: reference,
+    title: nullable(text2),
+    started_at: nullable(isoTime),
+    url: nullable(text2)
+  })),
+  /** What people said, wrote or a provider summarised from it, and the invitation's title: data, never instructions. */
+  untrusted: optional(array(text2))
+});
+var line = strictObject({
+  position: count2,
+  offset_ms: count2,
+  end_ms: count2,
+  speaker: nullable(text2),
+  text: text2
+});
+var meetingTranscript = strictObject({
+  ref: reference,
+  meeting: reference,
+  source: text2,
+  language: nullable(text2),
+  /** When a newer transcript of the same source replaced it; `meetings transcript --history` shows those too. */
+  superseded_at: nullable(isoTime),
+  created_at: isoTime,
+  lines: array(line)
+});
+var meetingSummary = strictObject({
+  id: pipe(string(), minLength(1)),
+  meeting: reference,
+  source: text2,
+  title: nullable(text2),
+  overview: nullable(text2),
+  sections: array(strictObject({ label: text2, text: text2 })),
+  next_steps: array(text2),
+  content: nullable(text2),
+  url: nullable(text2),
+  created_at: isoTime,
+  updated_at: isoTime
+});
+var meetingDetails = strictObject({
+  ...meeting.entries,
+  /** The stored event and series it belongs to, as `meetings_list` takes them. */
+  event_id: nullable(text2),
+  series_id: nullable(text2),
+  series_title: nullable(text2),
+  participants: array(strictObject({
+    name: nullable(text2),
+    email: nullable(text2),
+    role: nullable(text2),
+    joined_at: nullable(isoTime),
+    left_at: nullable(isoTime),
+    duration_ms: nullable(count2)
+  })),
+  transcripts: array(strictObject({ ref: reference, source: text2, language: nullable(text2), lines_count: count2 })),
+  chat: array(strictObject({ sent_at: isoTime, sender: nullable(text2), recipient: nullable(text2), text: text2 })),
+  summaries: array(meetingSummary),
+  attachments: array(strictObject({
+    position: count2,
+    kind: text2,
+    name: nullable(text2),
+    mime: nullable(text2),
+    size: nullable(count2),
+    url: nullable(text2)
+  }))
+});
+var meetingRef = /* @__PURE__ */ __name((accountId, meetingId) => formatMeetingReference({ type: "meeting", accountId, meetingId }), "meetingRef");
+var meetingTranscriptItem = /* @__PURE__ */ __name((accountId, transcript, rows) => ({
+  ref: formatMeetingReference({
+    type: "meeting",
+    accountId,
+    meetingId: transcript.meetingId,
+    transcriptId: transcript.id
+  }),
+  meeting: meetingRef(accountId, transcript.meetingId),
+  source: transcript.source,
+  language: transcript.language,
+  superseded_at: iso2(transcript.supersededAt),
+  created_at: new Date(transcript.externalCreatedAt ?? transcript.createdAt).toISOString(),
+  lines: rows.map((row) => ({
+    position: row.position,
+    offset_ms: row.startMs,
+    end_ms: row.endMs,
+    speaker: row.speakerName,
+    text: row.text
+  }))
+}), "meetingTranscriptItem");
+var meetingSummaryItem = /* @__PURE__ */ __name((accountId, summary) => ({
+  id: String(summary.id),
+  meeting: meetingRef(accountId, summary.meetingId),
+  source: summary.source,
+  title: summary.title,
+  overview: summary.overview,
+  sections: summary.sections.map(({ label, text: text6 }) => ({ label, text: text6 })),
+  next_steps: summary.nextSteps,
+  content: summary.content,
+  url: summary.docUrl,
+  created_at: new Date(summary.externalCreatedAt ?? summary.createdAt).toISOString(),
+  updated_at: new Date(summary.externalUpdatedAt ?? summary.updatedAt).toISOString()
+}), "meetingSummaryItem");
+var meetingDetailsItem = /* @__PURE__ */ __name((details, owner) => {
+  const { accountId } = details.meeting;
+  return {
+    ...meetingItem(details.meeting, owner),
+    event_id: details.meeting.eventId === null ? null : String(details.meeting.eventId),
+    series_id: details.meeting.meetingSeriesId === null ? null : String(details.meeting.meetingSeriesId),
+    series_title: details.series?.title ?? null,
+    participants: details.participants.map((one) => ({
+      name: one.displayName,
+      email: one.email,
+      role: one.role,
+      joined_at: iso2(one.joinedAt),
+      left_at: iso2(one.leftAt),
+      duration_ms: one.durationMs
+    })),
+    transcripts: details.transcripts.filter(({ transcript }) => transcript.supersededAt === null && transcript.deletedAt === null).map(({ transcript, rows }) => ({
+      ref: formatMeetingReference({
+        type: "meeting",
+        accountId,
+        meetingId: transcript.meetingId,
+        transcriptId: transcript.id
+      }),
+      source: transcript.source,
+      language: transcript.language,
+      lines_count: rows.length
+    })),
+    chat: details.chat.map((one) => ({
+      sent_at: new Date(one.sentAt).toISOString(),
+      sender: one.senderName,
+      recipient: one.recipient,
+      text: one.text
+    })),
+    summaries: details.summaries.map((one) => meetingSummaryItem(accountId, one)),
+    attachments: details.attachments.map((one) => ({
+      position: one.position,
+      kind: one.kind,
+      name: one.name ?? one.title,
+      mime: one.mime,
+      size: one.size,
+      url: one.url
+    }))
+  };
+}, "meetingDetailsItem");
+var wholeList = /* @__PURE__ */ __name((items) => ({
+  items,
+  page: { mode: "page", limit: Math.max(1, items.length), has_more: false }
+}), "wholeList");
+var PAGE_NEXT = STEPS.find((step) => step.id === "page.next");
+var MEETING_STEPS = defineSteps([
+  {
+    id: "meetings.search-again",
+    command: "*",
+    args: [],
+    why: "passages that changed since they were indexed were left out; the next search indexes them first"
+  }
+]);
+var SEARCH_AGAIN = MEETING_STEPS[0];
+var meetingHitItem = /* @__PURE__ */ __name((hit) => ({
+  ref: hit.ref,
+  meeting: meetingRef(parseMeetingReference(hit.ref).accountId, hit.meetingId),
+  scope: hit.scope,
+  id: String(hit.id),
+  excerpt: hit.text,
+  offset_ms: hit.startMs,
+  untrusted: hit.source === void 0 ? ["excerpt"] : ["excerpt", "source.title"],
+  ...hit.match === void 0 ? {} : { match: hit.match },
+  ...hit.corrections === void 0 ? {} : { corrections: hit.corrections },
+  ...hit.source === void 0 ? {} : {
+    source: {
+      ref: hit.ref,
+      title: hit.source.title,
+      started_at: iso2(hit.source.startedAt),
+      url: hit.source.url
+    }
+  }
+}), "meetingHitItem");
+var meetingHitsList = /* @__PURE__ */ __name((found, limit, command = "search meetings", args = {}, meta = {}) => {
+  const items = found.items.map(meetingHitItem);
+  const cursor = found.hasMore && found.nextCursor !== null ? found.nextCursor : void 0;
+  const pending = found.coverage.indexing === "pending";
+  const next = [
+    ...cursor === void 0 ? [] : [stepOf(PAGE_NEXT, { command, args: { ...args, cursor, limit }, values: { shown: items.length } })],
+    ...pending ? [
+      stepOf(SEARCH_AGAIN, {
+        command,
+        args: Object.fromEntries(Object.entries(args).filter(([key]) => key !== "cursor"))
+      })
+    ] : []
+  ];
+  return {
+    items,
+    page: {
+      mode: "cursor",
+      limit,
+      has_more: cursor !== void 0,
+      ...cursor === void 0 ? {} : { next_cursor: cursor }
+    },
+    ...next.length > 0 ? { next } : {},
+    ...pending ? {
+      missing: [
+        {
+          field: "excerpt",
+          why: "passages that changed since they were indexed were left out",
+          step: "meetings.search-again"
+        }
+      ]
+    } : {},
+    ...Object.keys(meta).length === 0 ? {} : { meta }
+  };
+}, "meetingHitsList");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/join-key.js
+var joinKeyOf = /* @__PURE__ */ __name((url) => {
+  const parsed = urlOf(url);
+  if (!parsed)
+    return null;
+  const host = parsed.hostname.toLowerCase().replace(/^www\./u, "");
+  const path = parsed.pathname.replace(/\/+$/u, "");
+  if (host === "zoom.us" || host.endsWith(".zoom.us") || host === "zoomgov.com" || host.endsWith(".zoomgov.com")) {
+    const number2 = /^\/(?:j|w|s|wc\/join|wc)\/(\d{9,12})(?:\/|$)/u.exec(path)?.[1];
+    if (number2)
+      return `zoom:${number2}`;
+  }
+  if (host === "meet.google.com") {
+    const code = /^\/([a-z]{3}-[a-z]{4}-[a-z]{3})$/iu.exec(path)?.[1];
+    if (code)
+      return `meet:${code.toLowerCase()}`;
+  }
+  return `${host}${path}`;
+}, "joinKeyOf");
+var joinUrlWithoutQuery = /* @__PURE__ */ __name((url) => {
+  const parsed = urlOf(url);
+  return parsed ? `${parsed.origin}${parsed.pathname}` : null;
+}, "joinUrlWithoutQuery");
+var urlOf = /* @__PURE__ */ __name((url) => {
+  if (!url?.trim())
+    return null;
+  try {
+    const parsed = new URL(url.trim());
+    return parsed.protocol === "https:" || parsed.protocol === "http:" ? parsed : null;
+  } catch {
+    return null;
+  }
+}, "urlOf");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/calendar-text.js
+var ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', "#39": "'", apos: "'", nbsp: " " };
+var SECRET_LINE = /(?<![\p{L}\p{N}])(pass ?codes?|passwords?|pwd|pins?|access ?codes?|meeting ?codes?|kennwort|пароль|пин-?код|код доступа)(?![\p{L}\p{N}])|pwd=/iu;
+var htmlToText = /* @__PURE__ */ __name((html) => html.replace(/<\s*br\s*\/?>/giu, "\n").replace(/<\/\s*(p|div|li|tr|h[1-6])\s*>/giu, "\n").replace(/<a\s[^>]*href\s*=\s*"([^"]*)"[^>]*>/giu, " $1 ").replace(/<[^>]+>/gu, "").replace(/&(amp|lt|gt|quot|#39|apos|nbsp);/gu, (_, name) => ENTITIES[name] ?? ""), "htmlToText");
+var withoutLinkQueries = /* @__PURE__ */ __name((text6) => text6.replace(/https?:\/\/[^\s<>"')\]]+/giu, (url) => joinUrlWithoutQuery(url) ?? ""), "withoutLinkQueries");
+var calendarText = /* @__PURE__ */ __name((text6, { dropSecretLines = true } = {}) => {
+  if (!text6)
+    return null;
+  const kept = htmlToText(text6).split(/\r?\n/u).map((line2) => withoutLinkQueries(line2).replace(/[ \t]+/gu, " ").trim()).filter((line2) => !dropSecretLines || !SECRET_LINE.test(line2));
+  const joined = kept.join("\n").replace(/\n{3,}/gu, "\n\n").trim();
+  return joined || null;
+}, "calendarText");
+var ENTRY_METADATA_KEYS = [
+  "colorId",
+  "guestsCanInviteOthers",
+  "guestsCanModify",
+  "guestsCanSeeOtherGuests",
+  "hangoutLink",
+  "locked",
+  "privateCopy"
+];
+var entryMetadata = /* @__PURE__ */ __name((metadata) => {
+  const kept = {};
+  for (const key of ENTRY_METADATA_KEYS) {
+    const value = metadata?.[key];
+    if (typeof value === "string")
+      kept[key] = withoutLinkQueries(value);
+    else if (typeof value === "number" || typeof value === "boolean")
+      kept[key] = value;
+  }
+  return kept;
+}, "entryMetadata");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/cue-fingerprint.js
+import { createHash } from "node:crypto";
+var meetingCueFingerprint = /* @__PURE__ */ __name((cue2) => createHash("sha256").update(JSON.stringify({
+  reference: cue2.reference,
+  transcriptId: cue2.transcriptId,
+  contentHash: cue2.contentHash,
+  position: cue2.position,
+  startMs: cue2.startMs,
+  endMs: cue2.endMs,
+  speakerParticipantId: cue2.speakerParticipantId,
+  speakerName: cue2.speakerName,
+  text: cue2.text
+})).digest("hex"), "meetingCueFingerprint");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/event-query.js
+var EVENT_QUERY = defineQuery({
+  entity: "event",
+  backend: "sql",
+  fields: [
+    { name: "id", type: "num", operators: ["term", "range"], example: "id:1" },
+    { name: "origin", type: "enum", operators: ["term"], values: ["auto", "owner"], example: "origin:owner" },
+    ...["starts_at", "ends_at", "created_at", "updated_at"].map((name) => ({
+      name,
+      type: "time",
+      operators: ["term", "range"],
+      example: `${name}>=2026-01-01`
+    }))
+  ]
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/event-store.js
+var UNTIL = /(?:^|;)UNTIL=(\d{4})(\d{2})(\d{2})(?:T(\d{2})(\d{2})(\d{2})Z?)?(?:;|$)/iu;
+var seriesEnd = /* @__PURE__ */ __name((entry) => {
+  if (entry.recurrenceEndsAt !== null)
+    return entry.recurrenceEndsAt;
+  const rule = entry.recurrence?.find((line2) => /^RRULE:/iu.test(line2));
+  const until = rule === void 0 ? null : UNTIL.exec(rule.slice("RRULE:".length));
+  if (!until)
+    return Number.POSITIVE_INFINITY;
+  const [, year, month, day, hour = "23", minute = "59", second = "59"] = until;
+  return Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second)) + 864e5;
+}, "seriesEnd");
+var entryInWindow = /* @__PURE__ */ __name((entry, window) => {
+  if (entry.kind === "occurrence" && !entry.exception)
+    return entry.originalStartsAt !== null && entry.originalStartsAt >= window.from && entry.originalStartsAt < window.to;
+  const start = entry.startsAt ?? (entry.kind === "occurrence" ? entry.originalStartsAt : null);
+  if (start === null || start >= window.to)
+    return false;
+  if (entry.kind === "series")
+    return seriesEnd(entry) >= window.from;
+  return Math.max(entry.endsAt ?? start, start + 1) > window.from;
+}, "entryInWindow");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/events.js
+var linkEvent = /* @__PURE__ */ __name(async (store, details, now = Date.now()) => {
+  const current = await store.meeting(details.meeting.id);
+  if (!current)
+    return null;
+  const { meeting: meeting2, series } = current;
+  if (meeting2.eventId !== null)
+    return (await store.events()).find((e) => e.id === meeting2.eventId) ?? null;
+  const candidates = meeting2.startedAt === null ? [] : await store.eventCandidates({
+    meetingSeriesId: meeting2.meetingSeriesId,
+    joinUrl: meeting2.joinUrl,
+    startsAt: meeting2.startedAt,
+    endsAt: meeting2.endedAt ?? meeting2.startedAt
+  });
+  if (candidates.length > 1) {
+    await store.reviewMeetingLink?.(meeting2.id, candidates.map(({ id: id3 }) => id3), now);
+    return null;
+  }
+  let event2 = candidates[0];
+  if (!event2) {
+    let eventSeriesId = series?.eventSeriesId ?? null;
+    if (series?.kind === "recurring" && eventSeriesId === null) {
+      const created = await store.createEventSeries({ title: series.title, recurrence: null, origin: "auto" }, now);
+      eventSeriesId = created.id;
+      await store.setEventSeries(series.id, eventSeriesId, now);
+    }
+    event2 = await store.createEvent({
+      eventSeriesId,
+      title: meeting2.title,
+      description: meeting2.description,
+      location: meeting2.location,
+      startsAt: meeting2.startedAt,
+      endsAt: meeting2.endedAt,
+      timezone: meeting2.timezone,
+      origin: "auto",
+      deletedAt: null
+    }, now);
+  }
+  await store.linkMeeting(meeting2.id, event2.id, now);
+  const linked = await store.meeting(meeting2.id);
+  return (await store.events()).find((e) => e.id === linked?.meeting.eventId) ?? null;
+}, "linkEvent");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/participant-search.js
+var normalizeMeetingParticipantQuery = /* @__PURE__ */ __name((text6) => text6.normalize("NFKC").toLowerCase(), "normalizeMeetingParticipantQuery");
+var validateMeetingParticipantQuery = /* @__PURE__ */ __name((query) => {
+  if (typeof query !== "string" || !query.trim() || query.length > 500 || query.includes("\0"))
+    throw new CliError("validation_error", "participant query must contain 1\u2013500 characters without NUL");
+  return normalizeMeetingParticipantQuery(query.trim());
+}, "validateMeetingParticipantQuery");
+var validateMeetingParticipantSearch = /* @__PURE__ */ __name((query, input) => {
+  input.signal?.throwIfAborted();
+  const normalized = validateMeetingParticipantQuery(query);
+  const bounded = /* @__PURE__ */ __name((value, maximum, name) => {
+    if (!Number.isSafeInteger(value) || value < 1 || value > maximum)
+      throw new CliError("validation_error", `${name} must be an integer from 1 through ${maximum}`);
+    return value;
+  }, "bounded");
+  return {
+    query: normalized,
+    accountId: bounded(input.accountId, Number.MAX_SAFE_INTEGER, "accountId"),
+    limit: bounded(input.limit ?? 50, 1e3, "limit"),
+    scanLimit: bounded(input.scanLimit ?? 1e3, 1e4, "scanLimit"),
+    maxReadBytes: bounded(input.maxReadBytes ?? 1024 ** 2, 64 * 1024 ** 2, "maxReadBytes")
+  };
+}, "validateMeetingParticipantSearch");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/reads.js
+var MeetingError = class extends CliError {
+  static {
+    __name(this, "MeetingError");
+  }
+  constructor(code, message) {
+    super(code, message);
+  }
+};
+var positiveInteger = /* @__PURE__ */ __name((value) => {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0)
+    throw new MeetingError("validation_error", "expected a positive integer");
+  return value;
+}, "positiveInteger");
+var validateFilter = /* @__PURE__ */ __name((filter) => {
+  for (const value of [filter.accountId, filter.eventId, filter.meetingSeriesId])
+    if (value !== void 0)
+      positiveInteger(value);
+  for (const value of [filter.since, filter.until])
+    if (value !== void 0 && !Number.isFinite(value))
+      throw new MeetingError("validation_error", "expected epoch milliseconds");
+  if (filter.since !== void 0 && filter.until !== void 0 && filter.since > filter.until)
+    throw new MeetingError("validation_error", "since must not exceed until");
+  for (const value of [filter.limit, filter.offset])
+    if (value !== void 0 && (!Number.isSafeInteger(value) || value < 0))
+      throw new MeetingError("validation_error", "expected a nonnegative integer");
+}, "validateFilter");
+var meetingShow = /* @__PURE__ */ __name(async (store, id3, accountId) => {
+  const details = await store.meeting(positiveInteger(id3));
+  if (!details || accountId !== void 0 && details.meeting.accountId !== accountId)
+    throw new MeetingError("not_found", "meeting not found");
+  return details;
+}, "meetingShow");
+var listed = /* @__PURE__ */ __name((items, page = { limit: items.length, hasMore: false }) => ({
+  items,
+  page: 1,
+  ...page
+}), "listed");
+var meetingPeople = /* @__PURE__ */ __name(async (store, query, accountId, options = {}) => {
+  if (accountId === void 0)
+    validateMeetingParticipantQuery(query);
+  else
+    validateMeetingParticipantSearch(query, { ...options, accountId });
+  if (store.participantCandidates && accountId === void 0)
+    throw new MeetingError("configuration_error", "select an account for bounded participant lookup");
+  if (accountId !== void 0 && store.participantCandidates) {
+    const { limit, has_more, next_cursor, ...packet } = await store.participantCandidates(query, {
+      ...options,
+      accountId
+    });
+    return {
+      ...packet,
+      page: { mode: "cursor", limit, has_more, ...next_cursor ? { next_cursor } : {} },
+      ...next_cursor ? {
+        next: [
+          stepOf(PAGE_NEXT2, {
+            command: "meetings people",
+            args: {
+              query,
+              limit,
+              ...options.scanLimit === void 0 ? {} : { scan_limit: options.scanLimit },
+              ...options.maxReadBytes === void 0 ? {} : { max_read_bytes: options.maxReadBytes },
+              cursor: next_cursor
+            },
+            values: { shown: packet.items.length }
+          })
+        ]
+      } : {}
+    };
+  }
+  if (Object.values(options).some((value) => value !== void 0))
+    throw new MeetingError("configuration_error", "bounded participant lookup needs a selected account and capable store");
+  return listed(await store.participants(query, accountId));
+}, "meetingPeople");
+var PAGE_NEXT2 = STEPS.find((step) => step.id === "page.next");
+var meetingsList = /* @__PURE__ */ __name(async (store, filter = {}, page = 1) => {
+  validateFilter(filter);
+  positiveInteger(page);
+  const limit = positiveInteger(filter.limit ?? 100);
+  const offset = (page - 1) * limit;
+  if (!Number.isSafeInteger(offset + limit + 1))
+    throw new MeetingError("validation_error", "pagination exceeds safe integer range");
+  const rows = await store.meetings({ ...filter, limit: limit + 1, offset });
+  const shown = rows.slice(0, limit);
+  const owners = /* @__PURE__ */ new Map();
+  for (const { accountId } of shown) {
+    if (owners.has(accountId))
+      continue;
+    const owner = await store.account(accountId);
+    if (!owner)
+      throw new MeetingError("not_found", `meeting account ${accountId} is not in the store`);
+    owners.set(accountId, owner);
+  }
+  const has_more = rows.length > limit;
+  return {
+    items: shown.map((row) => meetingItem(row, owners.get(row.accountId))),
+    page: { mode: "page", limit, has_more, ...has_more ? { next_page: page + 1 } : {} },
+    ...has_more ? {
+      next: [
+        stepOf(PAGE_NEXT2, { command: "meetings list", args: { page: page + 1, limit }, values: { shown: limit } })
+      ]
+    } : {}
+  };
+}, "meetingsList");
+var meetingsQuery = /* @__PURE__ */ __name((text6) => {
+  if (text6 === void 0 || text6.trim() === "")
+    return void 0;
+  const context3 = { command: "meetings list", guide: MEETING_QUERY_GUIDE };
+  const query = parseLucene(text6, { defaultField: "none", ...context3 });
+  validateQuery(query, MEETING_QUERY, context3);
+  return query;
+}, "meetingsQuery");
+var MEETING_QUERY_GUIDE = "https://github.com/WireCatLabs/cli-core/blob/main/docs/search/query-language.md";
+var ownerOf = /* @__PURE__ */ __name(async (store, accountId) => {
+  const owner = await store.account(accountId);
+  if (!owner)
+    throw new MeetingError("not_found", `meeting account ${accountId} is not in the store`);
+  return owner;
+}, "ownerOf");
+var meetingDetailsAnswer = /* @__PURE__ */ __name(async (store, id3, accountId) => {
+  const details = await meetingShow(store, id3, accountId);
+  return { item: meetingDetailsItem(details, await ownerOf(store, details.meeting.accountId)) };
+}, "meetingDetailsAnswer");
+var meetingTranscriptAnswer = /* @__PURE__ */ __name(async (store, id3, accountId, options = {}) => {
+  const details = await meetingShow(store, id3, accountId);
+  return wholeList(details.transcripts.filter((t) => (options.history || t.transcript.supersededAt === null) && t.transcript.deletedAt === null).map((t) => meetingTranscriptItem(details.meeting.accountId, t.transcript, t.rows)));
+}, "meetingTranscriptAnswer");
+var meetingSummaryAnswer = /* @__PURE__ */ __name(async (store, id3, accountId) => {
+  const details = await meetingShow(store, id3, accountId);
+  return wholeList(details.summaries.map((one) => meetingSummaryItem(details.meeting.accountId, one)));
+}, "meetingSummaryAnswer");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/export.js
+var timestamp = /* @__PURE__ */ __name((milliseconds) => {
+  if (!Number.isSafeInteger(milliseconds) || milliseconds < 0)
+    throw new MeetingError("validation_error", "transcript times must be nonnegative integer milliseconds");
+  const hours = Math.floor(milliseconds / 36e5);
+  const minutes = Math.floor(milliseconds % 36e5 / 6e4);
+  const seconds = Math.floor(milliseconds % 6e4 / 1e3);
+  return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}.${String(milliseconds % 1e3).padStart(3, "0")}`;
+}, "timestamp");
+var vttText = /* @__PURE__ */ __name((text6) => {
+  if (visibleControls(text6) !== text6 || /\n\s*\n/.test(text6))
+    throw new MeetingError("validation_error", "cue paragraphs or control characters require Markdown export");
+  return text6.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}, "vttText");
+var serializeVtt = /* @__PURE__ */ __name((lines) => `WEBVTT
+
+${lines.map((line2, index) => {
+  if (index > 0 && line2.startMs < (lines[index - 1]?.startMs ?? 0))
+    throw new MeetingError("validation_error", "WebVTT cues must have nondecreasing start times");
+  if (line2.endMs <= line2.startMs)
+    throw new MeetingError("validation_error", "a transcript cue ends before it starts");
+  const speaker = line2.speaker === null ? "" : `${vttText(line2.speaker)}: `;
+  if (line2.speaker?.includes("\n"))
+    throw new MeetingError("validation_error", "a speaker must fit on one line");
+  return `${index + 1}
+${timestamp(line2.startMs)} --> ${timestamp(line2.endMs)}
+${speaker}${vttText(line2.text)}
+
+`;
+}).join("")}`, "serializeVtt");
+var markdown = /* @__PURE__ */ __name((text6) => visibleControls(text6).replace(/[\\`*_{}[\]()<>#+.!|~]/g, "\\$&"), "markdown");
+var heading = /* @__PURE__ */ __name((text6) => markdown(singleLine(text6)), "heading");
+var quote = /* @__PURE__ */ __name((text6) => markdown(text6).split(/\r\n|\r|\n/).map((line2) => `> ${line2}`).join("\n"), "quote");
+var transcriptsOf = /* @__PURE__ */ __name((details, transcriptId) => {
+  if (transcriptId !== void 0) {
+    positiveInteger(transcriptId);
+    const transcript = details.transcripts.find((part) => part.transcript.id === transcriptId && part.transcript.deletedAt === null);
+    if (!transcript)
+      throw new MeetingError("not_found", "transcript not found in the selected meeting");
+    return [transcript];
+  }
+  return details.transcripts.filter((part) => part.transcript.supersededAt === null && part.transcript.deletedAt === null);
+}, "transcriptsOf");
+var exportMeeting = /* @__PURE__ */ __name(async (store, id3, options) => {
+  if (options.format !== "markdown" && options.format !== "vtt")
+    throw new MeetingError("validation_error", "export format must be markdown or vtt");
+  const details = await meetingShow(store, id3, options.accountId);
+  const transcripts = transcriptsOf(details, options.transcriptId);
+  let content;
+  if (options.format === "vtt") {
+    const [selected] = transcripts;
+    if (!selected)
+      throw new MeetingError("not_found", "meeting has no transcript to export");
+    if (transcripts.length > 1)
+      throw new MeetingError("validation_error", "choose a transcript id when exporting multiple transcripts as VTT");
+    content = serializeVtt([...selected.rows].sort((a, b) => a.position - b.position).map((row) => ({
+      startMs: row.startMs,
+      endMs: row.endMs,
+      speaker: row.speakerName,
+      text: row.text
+    })));
+  } else {
+    const parts = [`# ${heading(details.meeting.title ?? "Untitled meeting")}`, `Meeting ID: ${details.meeting.id}`];
+    if (details.meeting.description !== null)
+      parts.push("## Description", quote(details.meeting.description));
+    for (const summary of details.summaries) {
+      parts.push(`## ${heading(summary.title ?? "Summary")}`);
+      if (summary.content !== null)
+        parts.push(quote(summary.content));
+      else {
+        if (summary.overview !== null)
+          parts.push(quote(summary.overview));
+        for (const section of summary.sections)
+          parts.push(`### ${heading(section.label)}`, quote(section.text));
+        if (summary.nextSteps.length > 0)
+          parts.push("### Next steps", summary.nextSteps.map((step) => `- ${markdown(step)}`).join("\n"));
+      }
+    }
+    for (const part of transcripts) {
+      parts.push(`## Transcript ${part.transcript.id}`, `Source: ${heading(part.transcript.source)}`);
+      if (part.transcript.supersededAt !== null)
+        parts.push("Version: superseded");
+      for (const row of [...part.rows].sort((a, b) => a.position - b.position))
+        parts.push(`[${timestamp(row.startMs)} \u2013 ${timestamp(row.endMs)}]${row.speakerName === null ? "" : ` ${heading(row.speakerName)}`}`, quote(row.text));
+    }
+    content = `${parts.join("\n\n")}
+`;
+  }
+  return {
+    meetingId: details.meeting.id,
+    format: options.format,
+    filename: `meeting-${details.meeting.id}${options.transcriptId === void 0 ? "" : `-transcript-${options.transcriptId}`}.${options.format === "markdown" ? "md" : "vtt"}`,
+    content
+  };
+}, "exportMeeting");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/findings-rules.js
+import { createHash as createHash2 } from "node:crypto";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/timestamp.js
+var meetingTimestamp = /* @__PURE__ */ __name((value, name) => {
+  if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}T.+(?:Z|[+-]\d{2}:\d{2})$/i.test(value) || !Number.isFinite(Date.parse(value)))
+    throw new CliError("validation_error", `${name} must be an ISO timestamp with a timezone`);
+  const date = value.slice(0, 10);
+  const instant = Date.parse(`${date}T00:00:00Z`);
+  if (!Number.isFinite(instant) || new Date(instant).toISOString().slice(0, 10) !== date)
+    throw new CliError("validation_error", `${name} contains an invalid calendar date`);
+  return new Date(value).toISOString();
+}, "meetingTimestamp");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/meeting-management.js
+var nonempty = /* @__PURE__ */ __name((value, name) => {
+  if (typeof value !== "string" || !value.trim())
+    throw new CliError("validation_error", `${name} must be nonempty`);
+  return value;
+}, "nonempty");
+var validateMeetingChange = /* @__PURE__ */ __name((change, create) => {
+  if (!change || typeof change !== "object" || Array.isArray(change) || Object.keys(change).some((key) => !["title", "kind", "startTime", "durationMinutes", "timezone", "agenda"].includes(key)))
+    throw new CliError("validation_error", "unsupported meeting change field");
+  const result = {};
+  if (change.title !== void 0)
+    result.title = nonempty(change.title, "meeting title");
+  if (create && result.title === void 0)
+    throw new CliError("validation_error", "meeting title is required");
+  if (change.kind !== void 0) {
+    if (change.kind !== "instant" && change.kind !== "scheduled")
+      throw new CliError("validation_error", "only instant or scheduled meeting kinds are supported");
+    result.kind = change.kind;
+  }
+  if (change.startTime !== void 0) {
+    result.startTime = meetingTimestamp(change.startTime, "meeting start");
+  }
+  if (change.durationMinutes !== void 0) {
+    if (!Number.isSafeInteger(change.durationMinutes) || change.durationMinutes <= 0 || change.durationMinutes > 1440)
+      throw new CliError("validation_error", "meeting duration must be an integer from 1 to 1440 minutes");
+    result.durationMinutes = change.durationMinutes;
+  }
+  if (change.timezone !== void 0) {
+    if (typeof change.timezone !== "string" || !change.timezone.trim())
+      throw new CliError("validation_error", "meeting timezone must be a valid IANA timezone");
+    try {
+      new Intl.DateTimeFormat("en", { timeZone: change.timezone }).format();
+    } catch {
+      throw new CliError("validation_error", "meeting timezone must be a valid IANA timezone");
+    }
+    result.timezone = change.timezone;
+  }
+  if (change.agenda !== void 0) {
+    if (typeof change.agenda !== "string")
+      throw new CliError("validation_error", "meeting agenda must be text");
+    result.agenda = change.agenda;
+  }
+  if (create) {
+    result.kind ??= "scheduled";
+    if (result.kind === "scheduled" && result.startTime === void 0)
+      throw new CliError("validation_error", "scheduled meeting start is required");
+  } else if (!Object.keys(result).length)
+    throw new CliError("validation_error", "at least one meeting change is required");
+  return Object.freeze(result);
+}, "validateMeetingChange");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/meeting-context.js
+var MEETING_FACT_TYPES = ["fact", "statement", "question", "decision", "promise"];
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/findings-rules.js
+var TASK_TYPES = ["bug", "feature", "chore"];
+var invalid2 = /* @__PURE__ */ __name((message) => {
+  throw new CliError("validation_error", message);
+}, "invalid");
+var text3 = /* @__PURE__ */ __name((value, limit) => {
+  if (typeof value !== "string" || !value.trim() || value.includes("\0") || value.length > limit)
+    return invalid2(`finding text must contain 1\u2013${limit} characters without NUL`);
+  return value.trim();
+}, "text");
+var findingHash = /* @__PURE__ */ __name((value) => createHash2("sha256").update(JSON.stringify(value)).digest("hex"), "findingHash");
+var fields = /* @__PURE__ */ __name((value, allowed, noun) => {
+  if (Object.keys(value).some((key) => !allowed.includes(key)))
+    invalid2(`unknown ${noun} field`);
+}, "fields");
+var validateFindings = /* @__PURE__ */ __name((input, rules) => {
+  if (!input || typeof input !== "object" || Buffer.byteLength(JSON.stringify(input), "utf8") > 65536)
+    return invalid2(`${rules.plural} take at most 65536 UTF-8 bytes`);
+  fields(input, ["schemaVersion", "key", "extractor", "findings"], rules.singular);
+  if (input.schemaVersion !== 1 || !Array.isArray(input.findings) || input.findings.length < 1 || input.findings.length > 16)
+    return invalid2(`schemaVersion 1 takes 1\u201316 ${rules.plural}`);
+  const key = text3(input.key, 64);
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9_.:-]*$/.test(key))
+    return invalid2("a findings key uses letters, digits, dot, colon, underscore or hyphen");
+  const ids2 = /* @__PURE__ */ new Set();
+  const findings = input.findings.map((finding) => {
+    if (!finding || typeof finding !== "object")
+      return invalid2("a finding is an object");
+    const id3 = text3(finding.id, 64);
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9_.:-]*$/.test(id3) || ids2.has(id3))
+      return invalid2("finding IDs must be unique simple keys");
+    ids2.add(id3);
+    const project = text3(finding.project, 64);
+    if (!/^project:[1-9]\d*$/.test(project))
+      return invalid2("a finding names a project reference");
+    if (!Array.isArray(finding.evidence) || finding.evidence.length < 1 || finding.evidence.length > 8)
+      return invalid2(`a finding requires 1\u20138 cited ${rules.cited}s`);
+    const evidence = finding.evidence.map((item) => {
+      if (!item || typeof item !== "object")
+        return invalid2("finding evidence is a reference and fingerprint");
+      fields(item, ["reference", "fingerprint"], rules.singular);
+      if (typeof item.reference !== "string" || typeof item.fingerprint !== "string")
+        return invalid2("evidence requires a reference and fingerprint");
+      const reference2 = rules.reference(item.reference);
+      if (!/^[a-f0-9]{64}$/.test(item.fingerprint))
+        return invalid2(`finding evidence requires exact ${rules.cited} references and fingerprints`);
+      return { reference: reference2, fingerprint: item.fingerprint };
+    }).sort((a, b) => a.reference.localeCompare(b.reference));
+    if (new Set(evidence.map((item) => item.reference)).size !== evidence.length)
+      return invalid2(`duplicate evidence ${rules.cited}`);
+    const base = { id: id3, project, evidence };
+    if (finding.kind === "fact") {
+      fields(finding, ["id", "project", "evidence", "kind", "type", "statement"], rules.singular);
+      if (!MEETING_FACT_TYPES.includes(finding.type))
+        return invalid2("unknown fact finding type");
+      return { ...base, kind: "fact", type: finding.type, statement: text3(finding.statement, 2e3) };
+    }
+    if (finding.kind !== "task")
+      return invalid2("a finding is a fact or task");
+    fields(finding, [
+      "id",
+      "project",
+      "evidence",
+      "kind",
+      "type",
+      "title",
+      "reason",
+      "commitment",
+      "dueAt",
+      "dueEvidence",
+      "assignee",
+      "assigneeEvidence"
+    ], rules.singular);
+    if (!TASK_TYPES.includes(finding.type))
+      return invalid2("a task finding type is bug, chore or feature");
+    if (!["explicit", "inferred"].includes(finding.commitment))
+      return invalid2("task commitment must be explicit or inferred");
+    const support = /* @__PURE__ */ __name((value) => {
+      if (!Array.isArray(value) || value.length < 1 || value.length > 8 || value.some((ref) => typeof ref !== "string" || !evidence.some((item) => item.reference === ref)))
+        return invalid2("date and assignee support must cite the finding's evidence");
+      return [...new Set(value)].sort();
+    }, "support");
+    if (finding.dueAt === void 0 !== (finding.dueEvidence === void 0) || finding.assignee === void 0 !== (finding.assigneeEvidence === void 0))
+      return invalid2("optional dates and assignees require their supporting evidence");
+    if (finding.assignee !== void 0 && (typeof finding.assignee !== "string" || !/^person:[1-9]\d*$/.test(finding.assignee)))
+      return invalid2("an assignee must be a person reference");
+    return {
+      ...base,
+      kind: "task",
+      type: finding.type,
+      title: text3(finding.title, 300),
+      reason: text3(finding.reason, 2e3),
+      commitment: finding.commitment,
+      ...finding.dueAt === void 0 ? {} : { dueAt: meetingTimestamp(finding.dueAt, "finding due date"), dueEvidence: support(finding.dueEvidence) },
+      ...finding.assignee === void 0 ? {} : { assignee: finding.assignee, assigneeEvidence: support(finding.assigneeEvidence) }
+    };
+  });
+  return { schemaVersion: 1, key, extractor: text3(input.extractor, 200), findings };
+}, "validateFindings");
+var findingFingerprint = /* @__PURE__ */ __name(({ id: _id, ...finding }) => findingHash(finding), "findingFingerprint");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/findings.js
+var MEETING_FINDINGS_KIND = "meeting_findings";
+var cue = /* @__PURE__ */ __name((raw) => {
+  const reference2 = canonicalMeetingReference(raw);
+  if (parseMeetingReference(reference2).cuePosition === void 0)
+    throw new CliError("validation_error", "finding evidence requires exact cue references and fingerprints");
+  return reference2;
+}, "cue");
+var validateMeetingFindings = /* @__PURE__ */ __name((input) => validateFindings(input, { plural: "meeting findings", singular: "meeting finding", cited: "cue", reference: cue }), "validateMeetingFindings");
+var meetingFindingFingerprint = findingFingerprint;
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/hit-query.js
+var context = {
+  command: "search meetings",
+  guide: "https://github.com/WireCatLabs/cli-core/blob/main/docs/search/query-language.md#\u0432\u0441\u0442\u0440\u0435\u0447\u0438"
+};
+var words = ["term", "phrase"];
+var MOST_LINES_APART = 20;
+var near = /* @__PURE__ */ __name((node) => {
+  if (node.slop !== void 0 && node.slop > MOST_LINES_APART)
+    queryError("query.invalid-number", node.span, `words at most ${MOST_LINES_APART} lines apart: "a b"~${MOST_LINES_APART}`, context);
+}, "near");
+var MEETING_HIT_QUERY = defineQuery({
+  entity: "meeting_hit",
+  backend: "sql",
+  fields: [
+    {
+      name: "text",
+      type: "txt",
+      operators: words,
+      example: "text:budget",
+      relation: "a passage with the word in any form, or a spelling speech recognition garbled",
+      validate: near
+    },
+    {
+      name: "exact",
+      type: "txt",
+      operators: words,
+      example: "exact:budget",
+      relation: "a passage with the word as typed: no other forms, no garbled spellings",
+      validate: near
+    },
+    {
+      name: "from",
+      type: "kw",
+      operators: words,
+      example: 'from:"Alice Synthetic"',
+      relation: "a line said or a chat message written by this person; attendance is --identity-id"
+    }
+  ]
+});
+var MEETING_FIELDS = defineQuery({
+  entity: "meeting_hit",
+  backend: "sql",
+  fields: [
+    ...MEETING_HIT_QUERY.fields,
+    {
+      name: "date",
+      type: "time",
+      operators: ["term", "range"],
+      example: "date>=30d",
+      relation: "meetings that started then; the same as --since-time and --until-time"
+    },
+    ...["project", "tag", "topic"].map((name) => ({
+      name,
+      type: "kw",
+      operators: words,
+      example: `${name}:"Example name"`,
+      relation: `meetings in this ${name}, by name or alias; the same as --${name}`
+    }))
+  ]
+});
+var parseMeetingQuery = /* @__PURE__ */ __name((query) => validateQuery(parseLucene(query, { defaultField: "text", proximity: true, ...context }), MEETING_HIT_QUERY, context), "parseMeetingQuery");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/ingest.js
+var contentHash = /* @__PURE__ */ __name(async (text6) => {
+  const bytes = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text6));
+  return Array.from(new Uint8Array(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}, "contentHash");
+var speakerPosition = /* @__PURE__ */ __name((name, participants) => {
+  if (name === null)
+    return null;
+  const matches2 = participants.flatMap((p, i) => p.displayName === name ? [i] : []);
+  return matches2.length === 1 ? matches2[0] ?? null : null;
+}, "speakerPosition");
+var transcriptInput = /* @__PURE__ */ __name(async (lines, participants, source, hashText = JSON.stringify(lines), format = null) => ({
+  source,
+  format,
+  language: null,
+  contentHash: await contentHash(hashText),
+  externalCreatedAt: null,
+  metadata: null,
+  deletedAt: null,
+  rows: lines.map((line2, position) => ({
+    position,
+    startMs: line2.startMs,
+    endMs: line2.endMs,
+    speakerParticipantPosition: speakerPosition(line2.speaker, participants),
+    speakerName: line2.speaker,
+    text: line2.text,
+    normalizedText: null,
+    metadata: null
+  }))
+}), "transcriptInput");
+var timestamp2 = /* @__PURE__ */ __name((value) => {
+  const time = Date.parse(value);
+  if (!Number.isFinite(time))
+    throw new Error("Invalid meeting timestamp");
+  return time;
+}, "timestamp");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/transcript-text.js
+var TranscriptTextError = class extends Error {
+  static {
+    __name(this, "TranscriptTextError");
+  }
+  name = "TranscriptTextError";
+};
+var HEADER = {
+  "\u0412\u0441\u0442\u0440\u0435\u0447\u0430: ": "title",
+  "\u0414\u0430\u0442\u0430: ": "date",
+  "Zoom ID: ": "meetingId",
+  "\u0413\u043E\u0432\u043E\u0440\u044F\u0442: ": "speakers"
+};
+var LINE = /^\[(\d{2,}):([0-5]\d):([0-5]\d)\]\s*(?:([^:\n]{1,60}):\s*)?([\s\S]*)$/;
+var RULE = /^[—–-]{10,}[^\n]*(?:\n|$)/;
+var EMPTY = /* @__PURE__ */ new Set(["", "\u2014", "-"]);
+var parseTranscriptText = /* @__PURE__ */ __name((input) => {
+  const text6 = input.replace(/^/, "").replace(/\r\n?/g, "\n");
+  const header = { title: null, date: null, meetingId: null, speakers: [] };
+  let sawHeader = false;
+  for (const line2 of text6.split("\n")) {
+    if (!line2.trim())
+      break;
+    for (const [prefix, key] of Object.entries(HEADER)) {
+      if (!line2.startsWith(prefix))
+        continue;
+      sawHeader = true;
+      const value = line2.slice(prefix.length).trim();
+      if (key === "speakers")
+        header.speakers = value.split(",").map((name) => name.trim()).filter((name) => !EMPTY.has(name));
+      else
+        header[key] = EMPTY.has(value) ? null : value;
+    }
+  }
+  if (!sawHeader)
+    throw new TranscriptTextError('a text transcript starts with a header such as "\u0412\u0441\u0442\u0440\u0435\u0447\u0430: \u2026"');
+  const found = [];
+  for (const block of text6.split(/\n\s*\n/)) {
+    const match = LINE.exec(block.trim().replace(RULE, ""));
+    if (!match)
+      continue;
+    const [, hours = "0", minutes = "0", seconds = "0", speaker, said = ""] = match;
+    found.push({
+      startMs: ((Number(hours) * 60 + Number(minutes)) * 60 + Number(seconds)) * 1e3,
+      speaker: speaker?.trim() || null,
+      text: said.trim()
+    });
+  }
+  const lines = found.map((line2, at) => ({
+    ...line2,
+    endMs: Math.max(line2.startMs, found[at + 1]?.startMs ?? line2.startMs)
+  }));
+  return { header, lines };
+}, "parseTranscriptText");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/vtt.js
+var VttError = class extends Error {
+  static {
+    __name(this, "VttError");
+  }
+  name = "VttError";
+};
+var TIMESTAMP = /^(?:(\d+):)?([0-5]\d):([0-5]\d)\.(\d{3})$/;
+var SKIPPED = /^(NOTE|STYLE|REGION)(\s|$)/;
+var millis = /* @__PURE__ */ __name((stamp, lineNo) => {
+  const match = TIMESTAMP.exec(stamp);
+  if (!match)
+    throw new VttError(`line ${lineNo}: "${stamp}" is not a WebVTT timestamp`);
+  const [, hours = "0", minutes = "0", seconds = "0", ms = "0"] = match;
+  return ((Number(hours) * 60 + Number(minutes)) * 60 + Number(seconds)) * 1e3 + Number(ms);
+}, "millis");
+var splitSpeaker = /* @__PURE__ */ __name((text6) => {
+  const firstLine = text6.split("\n", 1)[0] ?? "";
+  const at = firstLine.indexOf(": ");
+  if (at <= 0)
+    return { speaker: null, text: text6 };
+  return { speaker: firstLine.slice(0, at).trim(), text: text6.slice(at + 2) };
+}, "splitSpeaker");
+var parseVtt = /* @__PURE__ */ __name((input) => {
+  const lines = input.replace(/^/, "").split(/\r\n|\r|\n/);
+  if (!/^WEBVTT([ \t].*)?$/.test(lines[0] ?? ""))
+    throw new VttError('line 1: a WebVTT file starts with "WEBVTT"');
+  const cues = [];
+  let i = lines.findIndex((line2) => line2.trim() === "");
+  if (i < 0)
+    return [];
+  while (i < lines.length) {
+    while (i < lines.length && lines[i]?.trim() === "")
+      i++;
+    const start = i;
+    while (i < lines.length && lines[i]?.trim() !== "")
+      i++;
+    const block = lines.slice(start, i);
+    if (block.length === 0 || SKIPPED.test(block[0] ?? ""))
+      continue;
+    const timingAt = block.findIndex((line2) => line2.includes("-->"));
+    if (timingAt < 0 || timingAt > 1)
+      throw new VttError(`line ${start + 1}: a cue has no timing line`);
+    const lineNo = start + timingAt + 1;
+    const [from = "", rest = ""] = (block[timingAt] ?? "").split("-->");
+    const to = rest.trim().split(/\s+/)[0] ?? "";
+    const text6 = block.slice(timingAt + 1).join("\n").trim();
+    cues.push({ startMs: millis(from.trim(), lineNo), endMs: millis(to, lineNo), ...splitSpeaker(text6) });
+  }
+  return cues;
+}, "parseVtt");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/import.js
+var importFiles = /* @__PURE__ */ __name(async (files, store, now = Date.now()) => {
+  const report = { meetings: 0, participants: 0, transcriptRows: 0, summaries: 0, warnings: [] };
+  for (const file of files) {
+    try {
+      const format = file.format ?? "vtt";
+      const lines = format === "text" ? parseTranscriptText(file.content).lines : parseVtt(file.content);
+      const participants = file.participants ?? [];
+      const details = await store.saveMeeting({
+        meeting: file.meeting,
+        participants: file.participants,
+        transcripts: [await transcriptInput(lines, participants, file.source ?? "file", file.content, format)],
+        now,
+        fromFile: true
+      });
+      await linkEvent(store, details, now);
+      report.meetings++;
+      report.participants += participants.length;
+      report.transcriptRows += lines.length;
+    } catch (error) {
+      report.warnings.push({
+        externalId: file.meeting.externalId,
+        message: error instanceof Error ? error.message : "Meeting import failed"
+      });
+    }
+  }
+  const zones = new Set(files.map((file) => file.meeting.timezone).filter((zone2) => zone2 !== null && zone2 !== void 0));
+  const [zone] = zones;
+  if (zones.size === 1 && zone)
+    report.timezone = zone;
+  return report;
+}, "importFiles");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/links.js
+var CHAT_MESSAGES_READ = 1e5;
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/passage.js
+var meetingHitContextLimits = /* @__PURE__ */ __name((options = {}) => {
+  const { before = 3, after = 3, bytes = 65536, max_read_bytes = 4194304, expected_fingerprint } = options;
+  if (![before, after].every((value) => Number.isSafeInteger(value) && value >= 0) || before + after > 999 || !Number.isSafeInteger(bytes) || bytes < 2 || bytes > 4194304 || !Number.isSafeInteger(max_read_bytes) || max_read_bytes < 1 || max_read_bytes > 67108864 || expected_fingerprint !== void 0 && (typeof expected_fingerprint !== "string" || !/^[a-f0-9]{64}$/.test(expected_fingerprint)))
+    throw new CliError("validation_error", "context takes 0\u2013999 surrounding cues, 2\u20134194304 output bytes and a bounded read budget");
+  return { before, after, bytes, max_read_bytes };
+}, "meetingHitContextLimits");
+var validateMeetingPassage = /* @__PURE__ */ __name((reference2, options) => {
+  meetingHitContextLimits(options);
+  if (typeof reference2 !== "string" || !reference2.trim() || reference2.length > 200 || options.format !== void 0 && !["json", "text", "markdown"].includes(options.format))
+    throw new CliError("validation_error", "choose a cue reference and json, text or markdown output");
+}, "validateMeetingPassage");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/preparation-context.js
+var validateMeetingPreparationContext = /* @__PURE__ */ __name((original) => {
+  if (!original || typeof original !== "object" || Array.isArray(original))
+    throw new CliError("validation_error", "meeting preparation context is required");
+  const input = { ...original };
+  for (const key of Object.keys(input))
+    if (!["accountId", "meetingId", "seriesId", "updatedAt", "limit", "maxReadBytes", "signal"].includes(key))
+      throw new CliError("validation_error", `unknown preparation context field: ${key}`);
+  if (input.signal !== void 0 && !(input.signal instanceof AbortSignal))
+    throw new CliError("validation_error", "signal must be an AbortSignal");
+  input.signal?.throwIfAborted();
+  for (const key of ["accountId", "meetingId", "seriesId"])
+    if (!Number.isSafeInteger(input[key]) || input[key] <= 0)
+      throw new CliError("validation_error", `${key} must be a positive safe integer`);
+  if (!Number.isSafeInteger(input.updatedAt) || Math.abs(input.updatedAt) > 864e13)
+    throw new CliError("validation_error", "updatedAt must be an absolute timestamp");
+  const limit = input.limit === void 0 ? 20 : input.limit;
+  const maxReadBytes = input.maxReadBytes === void 0 ? 262144 : input.maxReadBytes;
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100)
+    throw new CliError("validation_error", "limit must be an integer from 1 to 100");
+  if (!Number.isSafeInteger(maxReadBytes) || maxReadBytes < 1 || maxReadBytes > 4194304)
+    throw new CliError("validation_error", "maxReadBytes must be an integer from 1 to 4194304");
+  return { ...input, limit, maxReadBytes };
+}, "validateMeetingPreparationContext");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/project-evidence-answer.js
+var count3 = pipe(number(), integer(), minValue(0));
+var id = pipe(string(), minLength(1));
+var meetingProjectEvidence = strictObject({
+  schema_version: literal(1),
+  kind: literal("meeting_project_evidence"),
+  account_id: id,
+  query: string(),
+  project: strictObject({ id, name: string(), key: nullable(string()) }),
+  term: strictObject({
+    name: string(),
+    kind: picklist(["canonical", "key", "alias"]),
+    alias_id: optional(id)
+  }),
+  hits: array(meetingHit),
+  association: literal("unconfirmed-word-evidence"),
+  vocabulary_fingerprint: id,
+  selection: strictObject({
+    meeting_id: optional(id),
+    identity_id: optional(id),
+    person_id: optional(id),
+    tag_id: optional(id),
+    event_id: optional(id),
+    series_id: optional(id),
+    since: optional(isoTime),
+    until: optional(isoTime)
+  }),
+  limits: strictObject({ limit: count3, max_read_bytes: count3, max_vocabulary_read_bytes: count3, max_terms: count3 }),
+  page: pageSchema,
+  coverage: strictObject({
+    archive_completeness: literal("unknown"),
+    current_revisions: literal(true),
+    indexing: picklist(["ready", "pending"]),
+    index_completeness: literal("unknown"),
+    term_index: count3,
+    terms_total: count3,
+    remaining_terms: count3,
+    duplicates: literal("may-repeat-between-terms")
+  })
+});
+var PAGE_NEXT3 = STEPS.find((step) => step.id === "page.next");
+var meetingProjectEvidenceAnswer = /* @__PURE__ */ __name((page, prepared, command = "meetings projects evidence") => {
+  const { options } = prepared;
+  const selection = {};
+  for (const [field, value] of [
+    ["meeting_id", options.meetingId],
+    ["identity_id", options.participantIdentityId],
+    ["person_id", options.personId],
+    ["tag_id", options.tagId],
+    ["event_id", options.eventId],
+    ["series_id", options.meetingSeriesId]
+  ])
+    if (value !== void 0)
+      selection[field] = String(value);
+  if (options.since !== void 0)
+    selection.since = new Date(options.since).toISOString();
+  if (options.until !== void 0)
+    selection.until = new Date(options.until).toISOString();
+  const cursor = page.nextCursor ?? void 0;
+  if (page.hasMore !== (cursor !== void 0))
+    throw new CliError("invalid_response", "project evidence continuation is inconsistent");
+  const item = {
+    schema_version: 1,
+    kind: "meeting_project_evidence",
+    account_id: String(page.accountId),
+    query: page.query,
+    project: page.project,
+    term: {
+      name: page.term.name,
+      kind: page.term.kind,
+      ...page.term.aliasId === void 0 ? {} : { alias_id: page.term.aliasId }
+    },
+    hits: page.hits.map(meetingHitItem),
+    association: page.association,
+    vocabulary_fingerprint: page.vocabularyFingerprint,
+    selection,
+    limits: {
+      limit: page.limits.limit,
+      max_read_bytes: page.limits.maxReadBytes,
+      max_vocabulary_read_bytes: page.limits.maxVocabularyReadBytes,
+      max_terms: page.limits.maxTerms
+    },
+    page: {
+      mode: "cursor",
+      limit: page.limits.limit,
+      has_more: page.hasMore,
+      ...cursor === void 0 ? {} : { next_cursor: cursor }
+    },
+    coverage: {
+      archive_completeness: page.coverage.archiveCompleteness,
+      current_revisions: page.coverage.currentRevisions,
+      indexing: page.coverage.indexing,
+      index_completeness: page.coverage.indexCompleteness,
+      term_index: page.coverage.termIndex,
+      terms_total: page.coverage.termsTotal,
+      remaining_terms: page.coverage.remainingTerms,
+      duplicates: page.coverage.duplicates
+    }
+  };
+  if (!safeParse(meetingProjectEvidence, item).success)
+    throw new CliError("invalid_response", "project evidence does not match its answer contract");
+  return {
+    item,
+    ...cursor === void 0 ? {} : {
+      next: [
+        stepOf(PAGE_NEXT3, {
+          command,
+          args: {
+            project: prepared.project,
+            query: prepared.query,
+            cursor,
+            limit: page.limits.limit,
+            max_read_bytes: page.limits.maxReadBytes
+          },
+          values: { shown: page.hits.length }
+        })
+      ]
+    }
+  };
+}, "meetingProjectEvidenceAnswer");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/search-validation.js
+var validateMeetingHitSearch = /* @__PURE__ */ __name((query, options = {}) => {
+  const integer3 = /* @__PURE__ */ __name((value, low, high) => Number.isSafeInteger(value) && value >= low && value <= high, "integer");
+  if (typeof query !== "string" || !query.trim() || query.includes("\0") || new TextEncoder().encode(query).byteLength > 65536 || !integer3(options.limit ?? 100, 1, 1e3) || !integer3(options.maxReadBytes ?? 4194304, 1, 67108864) || [
+    options.meetingId,
+    options.participantIdentityId,
+    options.personId,
+    options.projectId,
+    options.tagId,
+    options.eventId,
+    options.meetingSeriesId
+  ].some((value) => value !== void 0 && !integer3(value, 1, Number.MAX_SAFE_INTEGER)) || [options.since, options.until].some((value) => value !== void 0 && !integer3(value, -864e13, 864e13)) || options.since !== void 0 && options.until !== void 0 && options.since > options.until || options.after !== void 0 && (typeof options.after !== "string" || !/^[A-Za-z0-9_-]{1,1000}$/.test(options.after)))
+    throw new CliError("validation_error", "invalid bounded meeting search query, cursor or limits");
+  for (const name of [options.project, options.tag, options.topic])
+    if (name !== void 0 && (typeof name !== "string" || !name.trim() || name.length > 200 || /[\p{Cc}\p{Cf}]/u.test(name)))
+      throw new CliError("validation_error", "a meeting vocabulary name takes 1\u2013200 characters without control characters");
+  if (options.project !== void 0 && options.projectId !== void 0 || [options.tag, options.topic, options.tagId].filter((value) => value !== void 0).length > 1)
+    throw new CliError("validation_error", "choose one project selector and one tag or topic selector");
+}, "validateMeetingHitSearch");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/project-evidence-query.js
+var ids = {
+  meeting_id: "meetingId",
+  identity_id: "participantIdentityId",
+  person_id: "personId",
+  tag_id: "tagId",
+  event_id: "eventId",
+  series_id: "meetingSeriesId"
+};
+var context2 = {
+  command: "meetings projects evidence",
+  guide: "https://github.com/WireCatLabs/cli-core/blob/main/docs/search/query-language.md"
+};
+var MEETING_PROJECT_EVIDENCE_QUERY = defineQuery({
+  entity: "meeting_project_evidence",
+  backend: "sql",
+  fields: [
+    ...Object.keys(ids).map((name) => ({
+      name,
+      type: "num",
+      operators: ["term"],
+      example: `${name}:12`,
+      placement: "and",
+      relation: "meetings selected by this stored ID; identity selects participants, not speakers"
+    })),
+    {
+      name: "started_at",
+      type: "time",
+      operators: ["term", "phrase", "range"],
+      example: "started_at:[2026-10-01 TO 2026-10-31]",
+      placement: "and",
+      relation: "the meeting start time in UTC"
+    }
+  ]
+});
+var requestKeys = /* @__PURE__ */ new Set(["query", "limit", "cursor", "maxReadBytes", "signal"]);
+var prepareMeetingProjectEvidence = /* @__PURE__ */ __name((project, request = {}, now = Date.now()) => {
+  if (!request || typeof request !== "object" || Array.isArray(request) || Object.keys(request).some((key) => !requestKeys.has(key)) || typeof project !== "string" || !project.trim() || project.length > 200 || /[\p{Cc}\p{Cf}]/u.test(project) || request.query !== void 0 && typeof request.query !== "string")
+    throw new CliError("validation_error", "expected an existing project and bounded evidence arguments");
+  if (request.query !== void 0 && new TextEncoder().encode(request.query).byteLength > 8192 || [request.limit, request.maxReadBytes].some((value) => value !== void 0 && typeof value !== "number"))
+    throw new CliError("validation_error", "invalid project evidence query or budget");
+  request.signal?.throwIfAborted();
+  const options = {
+    limit: request.limit ?? 100,
+    maxReadBytes: request.maxReadBytes ?? 4194304,
+    ...request.cursor === void 0 ? {} : { cursor: request.cursor },
+    ...request.signal === void 0 ? {} : { signal: request.signal }
+  };
+  const terms = /* @__PURE__ */ new Map();
+  if (request.query?.trim()) {
+    const ast = parseLucene(request.query, { defaultField: "none", ...context2 });
+    validateQuery(ast, MEETING_PROJECT_EVIDENCE_QUERY, context2);
+    const add = /* @__PURE__ */ __name((node) => {
+      if (terms.has(node.field))
+        queryError("query.unsupported-placement", node.span, "each field only once", context2);
+      terms.set(node.field, node);
+    }, "add");
+    if (ast.root.kind === "predicate")
+      add(ast.root);
+    else
+      for (const clause of ast.root.clauses) {
+        if (clause.occur !== "must" || clause.node.kind !== "predicate")
+          queryError("query.unsupported-placement", clause.node.span, "field:value terms joined by AND", context2);
+        add(clause.node);
+      }
+  }
+  const frozen = [];
+  for (const [field, key] of Object.entries(ids)) {
+    const term2 = terms.get(field);
+    if (!term2)
+      continue;
+    if (term2.operator !== "term" || !/^[1-9]\d*$/.test(term2.value) || !Number.isSafeInteger(Number(term2.value)))
+      queryError("query.unsupported-operator", term2.span, "one positive safe integer ID", context2);
+    options[key] = Number(term2.value);
+    frozen.push(`${field}:${term2.value}`);
+  }
+  const term = terms.get("started_at");
+  if (term) {
+    const range = dateRange(term.value, term.operator === "range" ? term.upper ?? "*" : term.value, term.lower_inclusive !== false, term.upper_inclusive !== false, "UTC", term.span, now);
+    if (range.lower !== void 0)
+      options.since = range.lower + (range.lower_inclusive ? 0 : 1);
+    if (range.upper !== void 0)
+      options.until = range.upper - (range.upper_inclusive ? 0 : 1);
+    frozen.push(`started_at:[${options.since === void 0 ? "*" : `"${new Date(options.since).toISOString()}"`} TO ${options.until === void 0 ? "*" : `"${new Date(options.until).toISOString()}"`}]`);
+  }
+  validateMeetingHitSearch(project, options);
+  if (options.cursor !== void 0 && (typeof options.cursor !== "string" || !/^[A-Za-z0-9_-]{1,4096}$/.test(options.cursor)))
+    throw new CliError("validation_error", "invalid project evidence cursor");
+  return { project: project.trim(), options, query: frozen.join(" AND ") };
+}, "prepareMeetingProjectEvidence");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/project-evidence.js
+var readMeetingProjectEvidence = /* @__PURE__ */ __name(async (read, project, request = {}, now = Date.now()) => {
+  const prepared = prepareMeetingProjectEvidence(project, request, now);
+  const page = await read(prepared.project, prepared.options);
+  prepared.options.signal?.throwIfAborted();
+  return meetingProjectEvidenceAnswer(page, prepared);
+}, "readMeetingProjectEvidence");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/pull.js
+var participantInput = /* @__PURE__ */ __name((p, provider, occurrenceId2, position, accountId) => {
+  const { identityExternalId, ...fields2 } = p;
+  const externalId = identityExternalId ?? (p.email ? `email:${p.email.toLowerCase()}` : p.externalId) ?? `name:${p.displayName ?? "unknown"}@${accountId}/${occurrenceId2}:${position}`;
+  return {
+    ...fields2,
+    identity: {
+      provider,
+      externalId,
+      name: p.displayName,
+      metadata: p.metadata,
+      associatePerson: Boolean(identityExternalId?.trim() || p.email?.trim() || p.externalId?.trim())
+    }
+  };
+}, "participantInput");
+var pull = /* @__PURE__ */ __name(async (source, store, options) => {
+  const now = options.now ?? Date.now();
+  const lookbackMs = options.lookbackMs ?? 0;
+  if (!Number.isSafeInteger(lookbackMs) || lookbackMs < 0 || lookbackMs > 31 * 864e5)
+    throw new Error("lookbackMs must be an integer from 0 through 31 days");
+  const since = options.since ?? await store.cursor(options.accountId) ?? new Date(now - 30 * 864e5).toISOString();
+  timestamp2(since);
+  const report = { meetings: 0, participants: 0, transcriptRows: 0, summaries: 0, warnings: [] };
+  let failed = false;
+  const from = timestamp2(since) - lookbackMs;
+  const meetings = await source.meetings(lookbackMs === 0 ? since : new Date(from).toISOString());
+  for (const m of meetings) {
+    const id3 = m.occurrence.id;
+    const read = /* @__PURE__ */ __name(async (part, call) => {
+      try {
+        return await call();
+      } catch (error) {
+        failed = true;
+        const message = error instanceof Error ? error.message : "could not be read";
+        report.warnings.push({ externalId: id3, message: `${part}: ${message}` });
+        return void 0;
+      }
+    }, "read");
+    try {
+      const sourceParticipants = await read("participants", () => source.participants(id3));
+      const participants = (sourceParticipants ?? []).map((p, i) => participantInput(p, source.provider, id3, i, options.accountId));
+      const names = /* @__PURE__ */ new Map();
+      for (const p of participants)
+        if (p.displayName !== null) {
+          const identities = names.get(p.displayName) ?? /* @__PURE__ */ new Set();
+          identities.add(p.identity.externalId);
+          names.set(p.displayName, identities);
+        }
+      if ([...names.values()].some((ids2) => ids2.size > 1))
+        report.warnings.push({ externalId: id3, message: "Participant names are ambiguous" });
+      const lines = await read("transcript", () => source.transcript(id3));
+      const chat = await read("chat", () => source.chat(id3));
+      const summary = await read("summary", () => source.summary(id3));
+      const attachments = await read("files", () => source.files(id3));
+      const startedAt = timestamp2(m.occurrence.startedAt);
+      const endedAt = m.occurrence.endedAt === null ? null : timestamp2(m.occurrence.endedAt);
+      if (endedAt !== null && endedAt < startedAt)
+        throw new Error("Meeting ends before it starts");
+      const meeting2 = {
+        accountId: options.accountId,
+        externalId: id3,
+        title: m.occurrence.title,
+        description: m.description ?? null,
+        location: m.location ?? null,
+        joinUrl: m.joinUrl ?? m.series?.joinUrl ?? null,
+        startedAt,
+        endedAt,
+        durationMs: endedAt === null ? null : endedAt - startedAt,
+        timezone: m.timezone ?? null,
+        hostIdentityId: null,
+        ...sourceParticipants === void 0 ? {} : { participantsCount: sourceParticipants?.length ?? null },
+        metadata: m.metadata ?? null,
+        deletedAt: null
+      };
+      if (m.series)
+        meeting2.series = {
+          externalId: m.series.id,
+          title: m.series.title,
+          description: null,
+          kind: m.series.kind ?? null,
+          recurrence: m.series.recurrence ?? null,
+          hostIdentityId: null,
+          joinUrl: m.series.joinUrl ?? null,
+          metadata: null,
+          deletedAt: null
+        };
+      const linked = sourceParticipants !== void 0;
+      const format = source.transcriptFormat ?? null;
+      const transcripts = lines && linked ? [await transcriptInput(lines, participants, source.name, void 0, format)] : void 0;
+      const details = await store.saveMeeting({
+        meeting: meeting2,
+        participants: sourceParticipants ? participants : void 0,
+        transcripts,
+        chat: chat?.map((line2) => ({
+          externalId: null,
+          sentAt: timestamp2(line2.sentAt),
+          senderParticipantPosition: speakerPosition(line2.sender, participants),
+          senderName: line2.sender,
+          recipient: null,
+          text: line2.text,
+          normalizedText: null,
+          metadata: null
+        })),
+        summaries: summary ? [
+          {
+            ...summary,
+            source: summary.source ?? source.name,
+            content: summary.content ?? null,
+            docUrl: summary.docUrl ?? null,
+            externalCreatedAt: summary.externalCreatedAt ?? null,
+            externalUpdatedAt: summary.externalUpdatedAt ?? null,
+            metadata: summary.metadata ?? null
+          }
+        ] : void 0,
+        attachments: attachments ?? void 0,
+        now
+      });
+      if (lines && !linked && !details.transcripts.some((t) => t.transcript.source === source.name && t.transcript.supersededAt === null))
+        await store.saveMeeting({
+          meeting: meeting2,
+          transcripts: [await transcriptInput(lines, [], source.name, `${JSON.stringify(lines)}
+unlinked`, format)],
+          now
+        });
+      await linkEvent(store, details, now);
+      report.meetings++;
+      report.participants += participants.length;
+      report.transcriptRows += lines?.length ?? 0;
+      report.summaries += summary ? 1 : 0;
+    } catch (error) {
+      failed = true;
+      report.warnings.push({ externalId: id3, message: error instanceof Error ? error.message : "Meeting pull failed" });
+    }
+  }
+  if (!failed)
+    await store.setCursor(options.accountId, new Date(now).toISOString(), now);
+  return report;
+}, "pull");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/read-answers.js
+var text4 = string();
+var count4 = pipe(number(), integer(), minValue(0));
+var id2 = pipe(number(), integer(), minValue(1));
+var iso3 = /* @__PURE__ */ __name((ms) => ms === null ? null : new Date(ms).toISOString(), "iso");
+var meetingReview = strictObject({
+  ref: reference,
+  id: pipe(string(), minLength(1)),
+  title: nullable(text4),
+  started_at: nullable(isoTime),
+  duration_ms: nullable(count4),
+  participants_count: nullable(count4),
+  projects: array(text4),
+  /** Null when the meeting has no current transcript. */
+  transcript: nullable(strictObject({ lines: count4, words: count4 })),
+  /** The three who talked longest. */
+  speakers: array(strictObject({ name: nullable(text4), talk_ms: count4 })),
+  /** The newest stored summary; null when there is none. */
+  summary: nullable(strictObject({
+    source: text4,
+    title: nullable(text4),
+    overview: nullable(text4),
+    next_steps: array(text4),
+    url: nullable(text4)
+  }))
+});
+var meetingLink = strictObject({
+  url: text4,
+  domain: nullable(text4),
+  /** The Google Docs, Sheets, Slides, Forms or Drive file it names. */
+  document_id: nullable(text4),
+  count: count4,
+  first_at: isoTime,
+  last_at: isoTime,
+  senders: array(text4),
+  meetings: array(strictObject({ ref: reference, title: nullable(text4) }))
+});
+var meetingSpeaker = strictObject({
+  /** `person:<id>`, `identity:<id>`, `name:<lowercased name>` or `unknown`. */
+  key: text4,
+  name: nullable(text4),
+  person_id: nullable(id2),
+  identity_id: nullable(id2),
+  meetings: count4,
+  lines: count4,
+  words: count4,
+  talk_ms: count4,
+  /** This speaker's part of all talk time, 0–1. */
+  share: pipe(number(), minValue(0), maxValue(1))
+});
+var meetingStats = strictObject({
+  time_zone: text4,
+  meetings: count4,
+  lines: count4,
+  words: count4,
+  talk_ms: count4,
+  /** `week_start` is the Monday, as a date in `time_zone`. */
+  weeks: array(strictObject({ week_start: text4, meetings: count4, talk_ms: count4 })),
+  top_speakers: array(meetingSpeaker)
+});
+var truncated = /* @__PURE__ */ __name((...why) => nullable(picklist(why)), "truncated");
+var meetingParticipants = strictObject({
+  schema_version: literal(1),
+  kind: literal("meeting_participants"),
+  account_id: id2,
+  query: text4,
+  items: array(strictObject({
+    participant_id: id2,
+    meeting_id: id2,
+    identity_id: id2,
+    display_name: nullable(text4),
+    email: nullable(text4)
+  })),
+  /** Several identities on one page are observations, never speaker attribution or person links. */
+  ambiguity: strictObject({ scope: literal("page"), multiple_identities: boolean(), identity_ids: array(id2) }),
+  coverage: strictObject({
+    scanned: count4,
+    read_bytes: count4,
+    archive_completeness: literal("unknown"),
+    truncated_by: truncated("limit", "scan_limit", "read_bytes")
+  }),
+  page: strictObject({
+    mode: literal("cursor"),
+    limit: count4,
+    has_more: boolean(),
+    next_cursor: optional(text4)
+  })
+});
+var revision = picklist(["current", "superseded"]);
+var meetingPassage = strictObject({
+  schema_version: literal(1),
+  kind: literal("meeting_context"),
+  source: reference,
+  target_ref: reference,
+  target_fingerprint: text4,
+  fingerprint: text4,
+  revision,
+  limits: strictObject({ before: count4, after: count4, bytes: count4, max_read_bytes: count4 }),
+  content_bytes: count4,
+  coverage: strictObject({
+    included: count4,
+    before: count4,
+    after: count4,
+    has_before: boolean(),
+    has_after: boolean(),
+    truncated_by: truncated("bytes"),
+    before_ref: nullable(reference),
+    after_ref: nullable(reference),
+    continuation: literal("anchor-inclusive"),
+    archive_completeness: literal("unknown"),
+    input: literal("bounded-meeting-context")
+  }),
+  items: array(strictObject({
+    ref: reference,
+    fingerprint: text4,
+    transcript_id: id2,
+    content_hash: nullable(text4),
+    position: count4,
+    start_ms: count4,
+    end_ms: count4,
+    speaker_participant_id: nullable(id2),
+    speaker_name: nullable(text4),
+    text: text4,
+    revision
+  }))
+});
+var event = strictObject({
+  id: pipe(string(), minLength(1)),
+  event_series_id: nullable(text4),
+  title: nullable(text4),
+  description: nullable(text4),
+  location: nullable(text4),
+  starts_at: nullable(isoTime),
+  ends_at: nullable(isoTime),
+  timezone: nullable(text4),
+  /** `auto`: made from a meeting; `owner`: made by hand; `calendar`: from a calendar's entries. */
+  origin: picklist(["auto", "owner", "calendar"]),
+  status: nullable(text4),
+  all_day: boolean(),
+  /** When its calendar deleted it: shown as "deleted in Google", kept as history. */
+  source_deleted_at: nullable(isoTime),
+  deleted_at: nullable(isoTime),
+  created_at: isoTime,
+  updated_at: isoTime,
+  /** The fields whoever sent the invitation wrote, on a calendar CLI's `events list`: an agent reads them as data. */
+  untrusted: optional(array(text4)),
+  /** On a calendar CLI's `events list changed:<date>`: what changed since then, and when the store saw it. */
+  change: optional(picklist(["new", "moved", "cancelled"])),
+  changed_at: optional(nullable(isoTime)),
+  /** The times a moved event had at that date. */
+  was: optional(strictObject({ starts_at: nullable(isoTime), ends_at: nullable(isoTime) })),
+  /** On a calendar CLI's `events list overlapping`: the events it clashes with, as `event:<id>`. */
+  overlaps: optional(array(text4))
+});
+var eventItem = /* @__PURE__ */ __name((one) => ({
+  id: String(one.id),
+  event_series_id: one.eventSeriesId === null ? null : String(one.eventSeriesId),
+  title: one.title,
+  description: one.description,
+  location: one.location,
+  starts_at: iso3(one.startsAt),
+  ends_at: iso3(one.endsAt),
+  timezone: one.timezone,
+  origin: one.origin,
+  status: one.status ?? null,
+  all_day: one.allDay === true,
+  source_deleted_at: iso3(one.sourceDeletedAt ?? null),
+  deleted_at: iso3(one.deletedAt),
+  created_at: new Date(one.createdAt).toISOString(),
+  updated_at: new Date(one.updatedAt).toISOString()
+}), "eventItem");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/recording-transfer.js
+var strongRecordingValidator = /* @__PURE__ */ __name((value) => typeof value === "string" && value.length <= 1024 && /^"[\x21\x23-\x7e\x80-\xff]*"$/.test(value), "strongRecordingValidator");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/related-history.js
+var validateMeetingRelatedHistory = /* @__PURE__ */ __name((original) => {
+  if (!original || typeof original !== "object" || Array.isArray(original))
+    throw new CliError("validation_error", "related history request is required");
+  const input = { ...original };
+  for (const field of Object.keys(input))
+    if (!["accountId", "seriesId", "anchorIds", "after", "before", "limit", "maxReadBytes", "signal"].includes(field))
+      throw new CliError("validation_error", `unknown related history field: ${field}`);
+  const positive = /* @__PURE__ */ __name((value) => Number.isSafeInteger(value) && value > 0, "positive");
+  if (!positive(input.accountId) || !positive(input.seriesId))
+    throw new CliError("validation_error", "accountId and seriesId must be positive safe integers");
+  if (!Array.isArray(input.anchorIds) || input.anchorIds.length > 20 || input.anchorIds.some((id3) => !positive(id3)))
+    throw new CliError("validation_error", "anchorIds must contain at most 20 positive safe integers");
+  for (const key of ["after", "before"])
+    if (!Number.isSafeInteger(input[key]) || Math.abs(input[key]) > 864e13)
+      throw new CliError("validation_error", `${key} must be an absolute timestamp`);
+  if (input.after >= input.before)
+    throw new CliError("validation_error", "after must precede before");
+  const limit = input.limit === void 0 ? 5 : input.limit;
+  const maxReadBytes = input.maxReadBytes === void 0 ? 262144 : input.maxReadBytes;
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > 20)
+    throw new CliError("validation_error", "limit must be an integer from 1 to 20");
+  if (!Number.isSafeInteger(maxReadBytes) || maxReadBytes < 1 || maxReadBytes > 4194304)
+    throw new CliError("validation_error", "maxReadBytes must be an integer from 1 to 4194304");
+  if (input.signal !== void 0 && !(input.signal instanceof AbortSignal))
+    throw new CliError("validation_error", "signal must be an AbortSignal");
+  input.signal?.throwIfAborted();
+  return { ...input, anchorIds: [...new Set(input.anchorIds)], limit, maxReadBytes };
+}, "validateMeetingRelatedHistory");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/result-items.js
+var text5 = string();
+var identifier = pipe(text5, minLength(1));
+var nullableText = nullable(text5);
+var count5 = pipe(number(), integer(), minValue(0));
+var flag = boolean();
+var scope = strictObject({ provider: text5, account: text5 });
+var run = strictObject({
+  meetings: count5,
+  participants: count5,
+  transcript_rows: count5,
+  summaries: count5,
+  warnings: array(strictObject({ external_id: text5, message: text5 })),
+  timezone: optional(text5)
+});
+var exported = union([
+  strictObject({ meeting_id: identifier, format: picklist(["markdown", "vtt"]), filename: text5, content: text5 }),
+  strictObject({ meeting_id: identifier, format: picklist(["markdown", "vtt"]), output: text5 })
+]);
+var eventChange = strictObject({
+  action: literal("event.link"),
+  event_id: nullable(identifier),
+  expected_event_id: optional(nullable(identifier))
+});
+var personChange = strictObject({
+  action: literal("person.link"),
+  participant_id: identifier,
+  person_uid: text5,
+  expected_person_uid: optional(nullableText),
+  target_account_ids: optional(array(identifier))
+});
+var eventResult = strictObject({
+  meeting_id: identifier,
+  event_id: nullable(identifier),
+  previous_event_id: nullable(identifier),
+  changed: flag
+});
+var personResult = strictObject({
+  meeting_id: identifier,
+  participant_id: identifier,
+  person_uid: text5,
+  previous_person_uid: nullableText,
+  changed: flag
+});
+var meetingChange = strictObject({
+  scope,
+  account_id: identifier,
+  meeting_id: identifier,
+  change: union([eventChange, personChange]),
+  applied: flag,
+  result: optional(union([eventResult, personResult]))
+});
+var recognition = strictObject({
+  engine: text5,
+  model: text5,
+  version: optional(text5),
+  timing: optional(picklist(["fixed-windows", "recognition-segments"]))
+});
+var transcription = union([
+  strictObject({
+    applied: literal(false),
+    account_id: identifier,
+    external_id: text5,
+    segments: count5,
+    media: strictObject({
+      id: text5,
+      content_hash: text5,
+      size: count5,
+      duration_ms: count5,
+      format: text5,
+      sample_rate: count5,
+      channels: count5,
+      recognition
+    })
+  }),
+  strictObject({
+    applied: literal(true),
+    account_id: identifier,
+    external_id: text5,
+    meeting_id: identifier,
+    created: flag,
+    inserted_transcripts: count5,
+    replayed_transcripts: count5,
+    superseded_transcripts: count5,
+    segments: count5,
+    media_sha256: text5,
+    engine: text5,
+    model: text5,
+    model_version: nullableText,
+    timing: picklist(["fixed-windows", "recognition-segments"])
+  })
+]);
+var embeddingModel = strictObject({ key: text5, dims: count5, kind: picklist(["local", "remote"]), model: text5 });
+var embedding = union([
+  strictObject({
+    account_id: identifier,
+    model: embeddingModel,
+    status: strictObject({ chunks: count5, embedded: count5 }),
+    applied: literal(false),
+    scope: literal("existing-current-chunks"),
+    rebuild_required: literal("explicit")
+  }),
+  strictObject({
+    account_id: identifier,
+    model: embeddingModel,
+    saved: count5,
+    skipped: count5,
+    has_more: flag,
+    next_hash: optional(text5),
+    applied: literal(true),
+    rebuild: strictObject({
+      transcripts: count5,
+      chunks: count5,
+      has_more: flag,
+      next_transcript_id: optional(identifier)
+    })
+  })
+]);
+var MEETING_RESULT_ENTITIES = {
+  meeting_ingestion: run,
+  meeting_export: exported,
+  meeting_association: meetingChange,
+  meeting_transcription: transcription,
+  meeting_embedding: embedding
+};
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/review.js
+var REVIEW_LIMIT = { default: 50, most: 200 };
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/save-hints.js
+var SAVE_HELP = `Worth keeping \u2014 a decision, a promise, a preference? Record it with \`memo facts add\` or
+\`memo memories add\`, citing the msg: locator or meeting: reference as --evidence.`;
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/series-history.js
+var validateMeetingSeriesHistory = /* @__PURE__ */ __name((input) => {
+  input.signal?.throwIfAborted();
+  if (!Number.isSafeInteger(input.accountId) || input.accountId <= 0)
+    throw new CliError("validation_error", "accountId must be a positive safe integer");
+  if (typeof input.externalId !== "string" || !input.externalId.trim() || new TextEncoder().encode(input.externalId).length > 4096 || /[\0\r\n]/.test(input.externalId))
+    throw new CliError("validation_error", "externalId must be a bounded nonempty series identifier");
+  for (const name of ["after", "before"])
+    if (!Number.isSafeInteger(input[name]) || Math.abs(input[name]) > 864e13)
+      throw new CliError("validation_error", `${name} must be an absolute timestamp in milliseconds`);
+  if (input.after >= input.before)
+    throw new CliError("validation_error", "after must be earlier than before");
+  const limit = input.limit === void 0 ? 20 : input.limit;
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100)
+    throw new CliError("validation_error", "limit must be an integer from 1 to 100");
+  const maxReadBytes = input.maxReadBytes === void 0 ? 256 * 1024 : input.maxReadBytes;
+  if (!Number.isSafeInteger(maxReadBytes) || maxReadBytes < 1 || maxReadBytes > 4 * 1024 * 1024)
+    throw new CliError("validation_error", "maxReadBytes must be an integer from 1 to 4194304");
+  return { ...input, limit, maxReadBytes };
+}, "validateMeetingSeriesHistory");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/upcoming-validation.js
+var occurrenceId = /* @__PURE__ */ __name((value) => typeof value === "string" && value.trim().length > 0 && value.length <= 1e3 && !/[\0\r\n]/.test(value), "occurrenceId");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/series-inventory-validation.js
+function invalid3(field, response = false) {
+  throw new CliError(response ? "invalid_response" : "validation_error", `invalid meeting inventory ${field}`);
+}
+__name(invalid3, "invalid");
+var object2 = /* @__PURE__ */ __name((value, fields2, field, response = false) => {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    invalid3(field, response);
+  for (const key of Object.keys(value))
+    if (!fields2.includes(key))
+      invalid3(`${field}.${key}`, response);
+}, "object");
+var cursorDetails = /* @__PURE__ */ __name((value) => {
+  if (typeof value !== "string" || value.length > 4096 || !/^[A-Za-z0-9_-]+$/.test(value))
+    invalid3("cursor");
+  try {
+    const decoded = JSON.parse(new TextDecoder("utf8", { fatal: true }).decode(Buffer.from(value, "base64url")));
+    object2(decoded, ["version", "selection", "cursor"], "cursor");
+    if (decoded.version !== 1 || typeof decoded.selection !== "string" || !/^[a-f0-9]{64}$/.test(decoded.selection) || !occurrenceId(decoded.cursor))
+      invalid3("cursor");
+    return decoded;
+  } catch {
+    return invalid3("cursor");
+  }
+}, "cursorDetails");
+var validateMeetingSeriesInventoryCursor = /* @__PURE__ */ __name((value) => {
+  cursorDetails(value);
+}, "validateMeetingSeriesInventoryCursor");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/meetings/stats.js
+var zoneOf = /* @__PURE__ */ __name((timeZone) => {
+  const zone = timeZone ?? "UTC";
+  try {
+    new Intl.DateTimeFormat("en", { timeZone: zone });
+  } catch {
+    throw new CliError("validation_error", "expected an IANA time zone such as Europe/Madrid");
+  }
+  return zone;
+}, "zoneOf");
+var DAYS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+var weekStart = /* @__PURE__ */ __name((at, format) => {
+  const parts = Object.fromEntries(format.formatToParts(new Date(at)).map((part) => [part.type, part.value]));
+  const day = Date.UTC(Number(parts.year), Number(parts.month) - 1, Number(parts.day));
+  return new Date(day - DAYS.indexOf(parts.weekday ?? "Mon") * 864e5).toISOString().slice(0, 10);
+}, "weekStart");
+var UNKNOWN_SPEAKER = "unknown";
+var speakerOf = /* @__PURE__ */ __name((row) => row.personId !== null ? { key: `person:${row.personId}`, name: row.personName ?? row.identityName ?? row.speakerName } : row.identityId !== null ? { key: `identity:${row.identityId}`, name: row.identityName ?? row.speakerName } : row.speakerName?.trim() ? { key: `name:${row.speakerName.trim().toLowerCase()}`, name: row.speakerName.trim() } : { key: UNKNOWN_SPEAKER, name: null }, "speakerOf");
+var aggregateMeetingStats = /* @__PURE__ */ __name((rows, timeZone) => {
+  const zone = zoneOf(timeZone);
+  const format = new Intl.DateTimeFormat("en-US", {
+    timeZone: zone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    weekday: "short"
+  });
+  const speakers = /* @__PURE__ */ new Map();
+  const weeks = /* @__PURE__ */ new Map();
+  const meetings = /* @__PURE__ */ new Set();
+  let lines = 0;
+  let words2 = 0;
+  let talkMs = 0;
+  for (const row of rows) {
+    const talk = Math.max(0, row.endMs - row.startMs);
+    meetings.add(row.meetingId);
+    lines += 1;
+    words2 += row.words;
+    talkMs += talk;
+    const who = speakerOf(row);
+    const held = speakers.get(who.key) ?? {
+      key: who.key,
+      name: who.name ?? null,
+      personId: row.personId,
+      identityId: row.personId === null ? row.identityId : null,
+      meetings: 0,
+      lines: 0,
+      words: 0,
+      talkMs: 0,
+      share: 0,
+      seen: /* @__PURE__ */ new Set()
+    };
+    held.seen.add(row.meetingId);
+    held.lines += 1;
+    held.words += row.words;
+    held.talkMs += talk;
+    speakers.set(who.key, held);
+    if (row.startedAt !== null) {
+      const week = weeks.get(weekStart(row.startedAt, format)) ?? { meetings: /* @__PURE__ */ new Set(), talkMs: 0 };
+      week.meetings.add(row.meetingId);
+      week.talkMs += talk;
+      weeks.set(weekStart(row.startedAt, format), week);
+    }
+  }
+  return {
+    timeZone: zone,
+    meetings: meetings.size,
+    lines,
+    words: words2,
+    talkMs,
+    speakers: [...speakers.values()].map(({ seen, ...speaker }) => ({
+      ...speaker,
+      meetings: seen.size,
+      share: talkMs === 0 ? 0 : Math.round(speaker.talkMs / talkMs * 1e3) / 1e3
+    })).sort((a, b) => b.talkMs - a.talkMs || a.key.localeCompare(b.key)),
+    weeks: [...weeks.entries()].map(([start, week]) => ({ weekStart: start, meetings: week.meetings.size, talkMs: week.talkMs })).sort((a, b) => a.weekStart.localeCompare(b.weekStart))
+  };
+}, "aggregateMeetingStats");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/domain/tags.js
+var TAG_TYPES = ["chat", "contact", "message", "task"];
+var TAG = /^[a-z0-9-]{1,32}$/;
+var tagOf = /* @__PURE__ */ __name((value) => {
+  const tag = value.trim().toLowerCase();
+  return TAG.test(tag) ? tag : void 0;
+}, "tagOf");
+var normalizeTag = /* @__PURE__ */ __name((value) => {
+  const tag = tagOf(value);
+  if (tag === void 0)
+    throw new CliError("validation_error", `"${singleLine(value)}" is not a tag \u2014 use 1\u201332 letters a\u2013z, digits and hyphens`, { reason: "tag.invalid" });
+  return tag;
+}, "normalizeTag");
+
+export {
+  QUERY_LIMITS,
+  queryAstSchema,
+  queryError,
+  walkQuery,
+  timezoneOf,
+  zonedMoment,
+  dateEndpoint,
+  dateRange,
+  evaluate,
+  FIELD_TYPES,
+  OPERATORS_BY_TYPE,
+  QUERY_BACKENDS,
+  queryFieldsOf,
+  fieldsHelp,
+  parseLucene,
+  implicitTextTerms,
+  validateQuery,
+  fieldsNamed,
+  describeQuery,
+  defineQuery,
+  QUERY_REASONS,
+  formatMeetingReference,
+  parseMeetingReference,
+  canonicalMeetingReference,
+  meeting,
+  MEETING_QUERY,
+  meetingHit,
+  meetingTranscript,
+  meetingSummary,
+  meetingDetails,
+  meetingHitsList,
+  joinKeyOf,
+  joinUrlWithoutQuery,
+  calendarText,
+  entryMetadata,
+  meetingCueFingerprint,
+  EVENT_QUERY,
+  entryInWindow,
+  normalizeMeetingParticipantQuery,
+  validateMeetingParticipantSearch,
+  MeetingError,
+  listed,
+  meetingPeople,
+  meetingsList,
+  meetingsQuery,
+  MEETING_QUERY_GUIDE,
+  meetingDetailsAnswer,
+  meetingTranscriptAnswer,
+  meetingSummaryAnswer,
+  exportMeeting,
+  validateMeetingChange,
+  findingHash,
+  validateFindings,
+  findingFingerprint,
+  MEETING_FINDINGS_KIND,
+  validateMeetingFindings,
+  meetingFindingFingerprint,
+  parseMeetingQuery,
+  importFiles,
+  CHAT_MESSAGES_READ,
+  validateMeetingPassage,
+  validateMeetingPreparationContext,
+  meetingProjectEvidence,
+  meetingProjectEvidenceAnswer,
+  validateMeetingHitSearch,
+  MEETING_PROJECT_EVIDENCE_QUERY,
+  prepareMeetingProjectEvidence,
+  readMeetingProjectEvidence,
+  pull,
+  meetingReview,
+  meetingLink,
+  meetingSpeaker,
+  meetingStats,
+  meetingParticipants,
+  meetingPassage,
+  event,
+  eventItem,
+  strongRecordingValidator,
+  validateMeetingRelatedHistory,
+  MEETING_RESULT_ENTITIES,
+  REVIEW_LIMIT,
+  SAVE_HELP,
+  validateMeetingSeriesHistory,
+  validateMeetingSeriesInventoryCursor,
+  aggregateMeetingStats,
+  TAG_TYPES,
+  tagOf,
+  normalizeTag
+};