@wirecat/zoom-cli 0.56.0 → 0.57.0

package/dist/bundle/chunk-G4VZDINN.js

@@ -0,0 +1,161 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  holdLock,
+  readLock,
+  releaseLock,
+  takeLock
+} from "./chunk-4R7HYNZS.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/mcp/http/state.js
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/mcp/http/activity.js
+import { randomBytes } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+var WRITE_EVERY_MS = 2e3;
+var TOOL_NAME = /^[A-Za-z0-9_.-]{1,64}$/;
+var httpActivityFile = /* @__PURE__ */ __name((tokenFile) => `${tokenFile.replace(/\.json$/, "")}.activity.json`, "httpActivityFile");
+var localDay = /* @__PURE__ */ __name((ms) => {
+  const d = new Date(ms);
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}, "localDay");
+var readActivity = /* @__PURE__ */ __name((path) => {
+  if (!existsSync(path))
+    return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}, "readActivity");
+var calledTools = /* @__PURE__ */ __name((body) => (Array.isArray(body) ? body : [body]).flatMap((message) => {
+  if (!message || typeof message !== "object")
+    return [];
+  const { method, params } = message;
+  const name = params?.name;
+  return method === "tools/call" && typeof name === "string" && TOOL_NAME.test(name) ? [name] : [];
+}), "calledTools");
+var activityRecorder = /* @__PURE__ */ __name((path, now = Date.now) => {
+  const activity = readActivity(path);
+  let timer;
+  const write = /* @__PURE__ */ __name(() => {
+    timer = void 0;
+    try {
+      mkdirSync(dirname(path), { recursive: true, mode: 448 });
+      const temporary = `${path}.${randomBytes(8).toString("hex")}.tmp`;
+      writeFileSync(temporary, JSON.stringify(activity), { mode: 384, flag: "wx" });
+      chmodSync(temporary, 384);
+      renameSync(temporary, path);
+    } catch {
+    }
+  }, "write");
+  return {
+    record: /* @__PURE__ */ __name((clientId, tools) => {
+      const at = now();
+      const iso = new Date(at).toISOString();
+      const day = localDay(at);
+      const before = activity[clientId];
+      const counted = before?.day === day ? before.toolCalls : 0;
+      const last = tools.at(-1);
+      activity[clientId] = {
+        lastRequestAt: iso,
+        day,
+        toolCalls: counted + tools.length,
+        ...last ? { lastTool: last, lastToolAt: iso } : before?.lastTool ? { lastTool: before.lastTool, ...before.lastToolAt ? { lastToolAt: before.lastToolAt } : {} } : {}
+      };
+      if (last) {
+        clearTimeout(timer);
+        write();
+      } else if (!timer) {
+        timer = setTimeout(write, WRITE_EVERY_MS);
+        timer.unref();
+      }
+    }, "record"),
+    flush: /* @__PURE__ */ __name(() => {
+      if (!timer)
+        return;
+      clearTimeout(timer);
+      write();
+    }, "flush")
+  };
+}, "activityRecorder");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/mcp/http/state.js
+var ACCESS_SECONDS = 60 * 60;
+var REFRESH_SECONDS = 30 * 24 * 60 * 60;
+var readStored = /* @__PURE__ */ __name((path) => existsSync2(path) ? JSON.parse(readFileSync2(path, "utf8")) : { clients: [], tokens: [] }, "readStored");
+var mcpHttpMarker = /* @__PURE__ */ __name((envPrefix) => `${envPrefix}_MCP_HTTP`, "mcpHttpMarker");
+var httpLogFile = /* @__PURE__ */ __name((tokenFile) => `${tokenFile.replace(/\.json$/, "")}.log`, "httpLogFile");
+var httpLockFile = /* @__PURE__ */ __name((tokenFile) => `${tokenFile.replace(/\.json$/, "")}.lock`, "httpLockFile");
+var httpLaunchFile = /* @__PURE__ */ __name((lockFile) => `${lockFile.replace(/\.lock$/, "")}.launch.json`, "httpLaunchFile");
+var readHttpLaunch = /* @__PURE__ */ __name((path) => {
+  try {
+    const launch = JSON.parse(readFileSync2(path, "utf8"));
+    return typeof launch.invocation === "string" && Array.isArray(launch.argv) && launch.argv.every((word) => typeof word === "string") && typeof launch.env === "object" && launch.env !== null ? launch : void 0;
+  } catch {
+    return void 0;
+  }
+}, "readHttpLaunch");
+var readHttpLock = /* @__PURE__ */ __name((path) => {
+  const lock = readLock(path);
+  return lock && typeof lock.port === "number" && typeof lock.publicUrl === "string" ? lock : void 0;
+}, "readHttpLock");
+var httpLock = /* @__PURE__ */ __name((path, first) => {
+  let current = first;
+  const held = takeLock(path, current);
+  return {
+    held,
+    update: /* @__PURE__ */ __name((change) => {
+      current = { ...current, ...change };
+      holdLock(path, current);
+    }, "update"),
+    release: /* @__PURE__ */ __name(() => releaseLock(path), "release")
+  };
+}, "httpLock");
+var signedInClients = /* @__PURE__ */ __name((tokenFile, now = Date.now()) => {
+  const seconds = Math.floor(now / 1e3);
+  const { clients, tokens } = readStored(tokenFile);
+  const activity = readActivity(httpActivityFile(tokenFile));
+  const today = localDay(now);
+  const last = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    if (token.expiresAt <= seconds)
+      continue;
+    const issued = token.expiresAt - (token.kind === "access" ? ACCESS_SECONDS : REFRESH_SECONDS);
+    last.set(token.clientId, Math.max(last.get(token.clientId) ?? 0, issued));
+  }
+  return clients.filter((client) => last.has(client.id)).map((client) => {
+    const did = activity[client.id];
+    return {
+      claimedName: client.name ?? null,
+      lastLoginAt: new Date((last.get(client.id) ?? 0) * 1e3).toISOString(),
+      lastRequestAt: did?.lastRequestAt ?? null,
+      lastTool: did?.lastTool ?? null,
+      lastToolAt: did?.lastToolAt ?? null,
+      toolCallsToday: did?.day === today ? did.toolCalls : 0
+    };
+  }).sort((a, b) => b.lastLoginAt.localeCompare(a.lastLoginAt));
+}, "signedInClients");
+
+export {
+  httpActivityFile,
+  calledTools,
+  activityRecorder,
+  ACCESS_SECONDS,
+  REFRESH_SECONDS,
+  readStored,
+  mcpHttpMarker,
+  httpLogFile,
+  httpLockFile,
+  httpLaunchFile,
+  readHttpLaunch,
+  readHttpLock,
+  httpLock,
+  signedInClients
+};

package/dist/bundle/chunk-GARCOIB6.js

@@ -0,0 +1,409 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  CliError,
+  singleLine
+} from "./chunk-AE4BOXH7.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/domain/providers.js
+var KINDS = ["messages", "mail", "notes", "documents", "meetings", "events"];
+var PROVIDERS = [
+  { name: "telegram", kind: "messages", aliases: ["tg"] },
+  { name: "telegram-bot", kind: "messages", aliases: ["tg-bot"] },
+  { name: "max", kind: "messages", aliases: [] },
+  { name: "max-bot", kind: "messages", aliases: [] },
+  { name: "whatsapp", kind: "messages", aliases: ["wa"] },
+  { name: "whatsapp-bot", kind: "messages", aliases: ["wa-bot"] },
+  { name: "email", kind: "mail", aliases: [] },
+  { name: "notes", kind: "notes", aliases: [] },
+  { name: "local", kind: "notes", aliases: [] },
+  { name: "obsidian", kind: "notes", aliases: [] },
+  { name: "zoom", kind: "meetings", aliases: [] }
+];
+var FOLDER_PROVIDERS = ["local", "obsidian", "folder"];
+var isFolderProvider = /* @__PURE__ */ __name((provider) => FOLDER_PROVIDERS.includes(provider), "isFolderProvider");
+var folderProviderSql = /* @__PURE__ */ __name((column = "provider") => `${column} IN (${FOLDER_PROVIDERS.map((name) => `'${name}'`).join(", ")})`, "folderProviderSql");
+var folderProviderOf = /* @__PURE__ */ __name((format) => format === "markdown" ? "local" : "obsidian", "folderProviderOf");
+var DOCUMENT_ACCOUNT_PROVIDERS = ["google-drive"];
+var isDocumentAccountProvider = /* @__PURE__ */ __name((provider) => DOCUMENT_ACCOUNT_PROVIDERS.includes(provider), "isDocumentAccountProvider");
+var filesAccountSql = /* @__PURE__ */ __name((column = "provider") => `${column} IN (${[...FOLDER_PROVIDERS, ...DOCUMENT_ACCOUNT_PROVIDERS].map((name) => `'${name}'`).join(", ")})`, "filesAccountSql");
+var INTERNAL_NOTES = "internal";
+var UNKNOWN_PROVIDER = "unknown provider \u2014 run its CLI once";
+var WORD = /^[a-z0-9][a-z0-9_-]*$/;
+var invalid = /* @__PURE__ */ __name((message) => {
+  throw new CliError("validation_error", message);
+}, "invalid");
+var wordOf = /* @__PURE__ */ __name((value, what) => typeof value === "string" && WORD.test(value) ? value : invalid(`${what} is lowercase letters, digits, - and _ \u2014 not ${JSON.stringify(value)}`), "wordOf");
+var providerEntryOf = /* @__PURE__ */ __name((value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return invalid("a provider entry is an object");
+  const { name, kind, aliases = [], command } = value;
+  const named = wordOf(name, "a provider's name");
+  if (typeof kind !== "string" || !KINDS.includes(kind))
+    invalid(`provider ${named}'s kind is one of ${KINDS.join(", ")} \u2014 not ${JSON.stringify(kind)}`);
+  if (!Array.isArray(aliases))
+    invalid(`provider ${named}'s aliases are a list`);
+  return {
+    name: named,
+    kind,
+    aliases: [...new Set(aliases.map((alias) => wordOf(alias, `an alias of ${named}`)))],
+    ...command === void 0 ? {} : { command: wordOf(command, `the command of ${named}`) }
+  };
+}, "providerEntryOf");
+var describe = /* @__PURE__ */ __name(({ name, kind, command }) => `${name} (${kind}${command ? `, from ${command}` : ""})`, "describe");
+var wordsOf = /* @__PURE__ */ __name(({ name, aliases }) => [name, ...aliases], "wordsOf");
+var joined = /* @__PURE__ */ __name((known, entry) => {
+  const same = known.find(({ name }) => name === entry.name);
+  if (same && same.kind !== entry.kind)
+    invalid(`two provider entries disagree on the kind: ${describe(same)} and ${describe(entry)}`);
+  const merged = same ? {
+    ...same,
+    aliases: [.../* @__PURE__ */ new Set([...same.aliases, ...entry.aliases])],
+    ...entry.command ? { command: entry.command } : {}
+  } : entry;
+  const others = known.filter((one) => one !== same);
+  for (const word of wordsOf(merged)) {
+    const owner = others.find((one) => wordsOf(one).includes(word));
+    if (owner)
+      invalid(`"${word}" names two providers: ${describe(owner)} and ${describe(merged)}`);
+  }
+  return same ? known.map((one) => one === same ? merged : one) : [...known, merged];
+}, "joined");
+var registry = PROVIDERS;
+var providers = /* @__PURE__ */ __name(() => registry, "providers");
+var useProviders = /* @__PURE__ */ __name((entries) => {
+  registry = entries.map(providerEntryOf).reduce(joined, PROVIDERS);
+}, "useProviders");
+var useStoredProviders = /* @__PURE__ */ __name((entries) => {
+  const left = [];
+  registry = entries.reduce((known, entry) => {
+    try {
+      return joined(known, providerEntryOf(entry));
+    } catch (error) {
+      if (!(error instanceof CliError))
+        throw error;
+      left.push(entry);
+      return known;
+    }
+  }, PROVIDERS);
+  return left;
+}, "useStoredProviders");
+var addProvider = /* @__PURE__ */ __name((entry) => {
+  registry = joined(registry, providerEntryOf(entry));
+}, "addProvider");
+var isKind = /* @__PURE__ */ __name((word) => KINDS.includes(word.toLowerCase()), "isKind");
+var providerNamed = /* @__PURE__ */ __name((word) => {
+  const wanted = word.toLowerCase();
+  return registry.find((entry) => wordsOf(entry).includes(wanted));
+}, "providerNamed");
+var kindIn = /* @__PURE__ */ __name((provider) => isFolderProvider(provider) ? "notes" : registry.find(({ name }) => name === provider)?.kind, "kindIn");
+var kindOf = /* @__PURE__ */ __name((provider) => kindIn(provider) ?? "messages", "kindOf");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/domain/locator.js
+var SCHEME = "msg:";
+var formatLocator = /* @__PURE__ */ __name(({ provider, account, chat, message }) => SCHEME + [provider, account, chat, message].map(encodeURIComponent).join("/"), "formatLocator");
+var isLocator = /* @__PURE__ */ __name((reference) => reference.trim().startsWith(SCHEME), "isLocator");
+var parseLocator = /* @__PURE__ */ __name((reference) => {
+  const trimmed = reference.trim();
+  const parts2 = trimmed.startsWith(SCHEME) ? trimmed.slice(SCHEME.length).split("/") : [];
+  if (parts2.length !== 4 || parts2.some((part) => part === "")) {
+    throw new CliError("validation_error", `"${singleLine(reference)}" is not a message locator \u2014 expected msg:<provider>/<account>/<chat>/<message>`);
+  }
+  const [provider, account, chat, message] = parts2.map(decodeURIComponent);
+  return { provider, account, chat, message };
+}, "parseLocator");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/domain/references.js
+var SIMPLE_REFERENCES = [
+  "note",
+  "document",
+  "person",
+  "organization",
+  "project",
+  "task",
+  "memory",
+  "fact",
+  "bot",
+  "entity"
+];
+var parts = /* @__PURE__ */ __name((rest, count, reference, shape) => {
+  const split = rest.split("/");
+  if (split.length !== count || split.some((part) => part === ""))
+    throw new CliError("validation_error", `"${singleLine(reference)}" is not a reference \u2014 expected ${shape}`);
+  return split.map(decodeURIComponent);
+}, "parts");
+var formatReference = /* @__PURE__ */ __name((reference) => {
+  switch (reference.type) {
+    case "message":
+      return formatLocator(reference);
+    case "chat":
+      return `chat:${[reference.provider, reference.account, reference.chat].map(encodeURIComponent).join("/")}`;
+    case "contact":
+      return `contact:${[reference.provider, reference.id].map(encodeURIComponent).join("/")}`;
+    case "folder":
+      return reference.path === null ? `folder:${encodeURIComponent(reference.id)}` : `folder:${encodeURIComponent(reference.id)}/${encodeURIComponent(reference.path)}`;
+    default:
+      return `${reference.type}:${reference.id}`;
+  }
+}, "formatReference");
+var parseReference = /* @__PURE__ */ __name((text) => {
+  const reference = text.trim();
+  const colon = reference.indexOf(":");
+  const prefix = colon < 0 ? "" : reference.slice(0, colon);
+  const rest = reference.slice(colon + 1);
+  switch (prefix) {
+    case "msg":
+      return { type: "message", ...parseLocator(reference) };
+    case "chat": {
+      const [provider, account, chat] = parts(rest, 3, reference, "chat:<provider>/<account>/<chat>");
+      return { type: "chat", provider, account, chat };
+    }
+    case "contact": {
+      const [provider, id] = parts(rest, 2, reference, "contact:<provider>/<id>");
+      return { type: "contact", provider, id };
+    }
+    case "folder": {
+      const slash = rest.indexOf("/");
+      const id = decodeURIComponent(slash < 0 ? rest : rest.slice(0, slash));
+      const path = slash < 0 ? null : folderPath(decodeURIComponent(rest.slice(slash + 1)));
+      if (!id.trim() || path === "")
+        throw new CliError("validation_error", `"${singleLine(reference)}" is not a reference \u2014 expected folder:<id>[/<path>]`);
+      return { type: "folder", id, path };
+    }
+    default:
+      if (SIMPLE_REFERENCES.includes(prefix)) {
+        if (!rest.trim())
+          throw new CliError("validation_error", `"${singleLine(reference)}" names no ${prefix}`);
+        return { type: prefix, id: rest };
+      }
+      throw new CliError("validation_error", `"${singleLine(reference)}" is not a reference \u2014 expected msg:, chat:, contact:, folder:, ${SIMPLE_REFERENCES.filter((one) => one !== "entity").join(":, ")}:`);
+  }
+}, "parseReference");
+var folderPath = /* @__PURE__ */ __name((path) => {
+  const clean = path.split("/").filter((part) => part !== "" && part !== ".").join("/");
+  return clean === "" ? path.trim() === "" ? "" : null : clean;
+}, "folderPath");
+var canonicalReference = /* @__PURE__ */ __name((text) => formatReference(parseReference(text)), "canonicalReference");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/domain/counters.js
+var COUNTER_FIELDS = ["views", "reactions", "comments"];
+var validCounter = /* @__PURE__ */ __name((value) => typeof value === "number" && Number.isFinite(value) && value >= 0, "validCounter");
+var counterValue = /* @__PURE__ */ __name((message, field) => {
+  const value = field === "reactions" ? message.reactions?.total : message.providerMetadata?.[field];
+  return validCounter(value) ? value : null;
+}, "counterValue");
+var counterObservationTime = /* @__PURE__ */ __name((observation, now) => {
+  const at = Date.parse(observation.observedAt);
+  if (!validCounter(observation.value) || !Number.isSafeInteger(at) || at < 0 || at > now || !["remote_fetch", "remote_update"].includes(observation.source))
+    throw new CliError("validation_error", "counter observation needs a valid value, source and nonfuture observation time");
+  if (observation.reactions && (!validCounter(observation.reactions.total) || observation.reactions.total !== observation.value))
+    throw new CliError("validation_error", "reaction observation payload and total disagree");
+  return at;
+}, "counterObservationTime");
+var observedCounters = /* @__PURE__ */ __name((message, observedAt, fields, source = "remote_fetch") => {
+  const observations = {};
+  for (const field of fields) {
+    const value = counterValue(message, field);
+    if (value !== null)
+      observations[field] = {
+        value,
+        observedAt,
+        source,
+        ...field === "reactions" && message.reactions ? { reactions: message.reactions } : {}
+      };
+  }
+  return { ...message, counterObservations: observations };
+}, "observedCounters");
+var counterFreshness = /* @__PURE__ */ __name((states) => {
+  if (!states.length || states.every((one) => one.freshness === "unknown"))
+    return "unknown";
+  if (states.some((one) => one.freshness === "unknown"))
+    return "partial";
+  return states.some((one) => one.freshness === "stale") ? "stale" : "fresh";
+}, "counterFreshness");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/domain/rankings-options.js
+var MESSAGE_MEASURES = ["views", "reactions", "forwards", "comments", "replies", "thread-size"];
+var AUTHOR_MEASURES = [
+  "messages",
+  "words",
+  "reactions",
+  "replies",
+  "answers",
+  "answer-time",
+  "threads",
+  "active-days"
+];
+var CONTEXT = /* @__PURE__ */ new Set([
+  "replies",
+  "replies-from-others",
+  "replies-from-others-per-message",
+  "thread-size",
+  "threads",
+  "answers",
+  "answer-time"
+]);
+var needsRankingContext = /* @__PURE__ */ __name((options) => options.components.some((name) => CONTEXT.has(name)), "needsRankingContext");
+var presets = {
+  helpful: { answers: 0.5, "replies-from-others": 0.25, reactions: 0.25 },
+  active: { "active-days": 0.6, messages: 0.4 },
+  engaging: { "reactions-per-message": 0.5, "replies-from-others-per-message": 0.5 }
+};
+function invalid2(message) {
+  throw new CliError("validation_error", message, { reason: "ranking.invalid" });
+}
+__name(invalid2, "invalid");
+var rankingOptions = /* @__PURE__ */ __name((target, input) => {
+  const measures = target === "messages" ? MESSAGE_MEASURES : AUTHOR_MEASURES;
+  const { measure, score, weights: given, minMessages } = input;
+  const messageKind = input.messageKind ?? "all";
+  if (!["all", "posts", "comments"].includes(messageKind))
+    invalid2("message_kind takes all, posts or comments");
+  if (target === "messages" && minMessages !== void 0)
+    invalid2("min_messages applies to stats contacts top");
+  if (minMessages !== void 0 && (!Number.isSafeInteger(minMessages) || minMessages < 1))
+    invalid2("min_messages takes a positive integer");
+  if (measure !== void 0 && !measures.includes(measure))
+    invalid2(`--measure takes ${measures.join(", ")}`);
+  if (measure !== void 0 && (score !== void 0 || given !== void 0))
+    invalid2("--measure cannot be combined with --score or --weights");
+  if (score !== void 0 && !["helpful", "active", "engaging"].includes(score))
+    invalid2("--score takes helpful, active or engaging");
+  if (target === "messages" && score !== void 0 && score !== "engaging")
+    invalid2("helpful and active scores apply to authors only");
+  const scoring = score !== void 0 || given !== void 0;
+  const preset = score;
+  let weights = null;
+  if (scoring) {
+    let raw = given !== void 0 ? given : target === "messages" ? { reactions: 0.5, "replies-from-others": 0.5 } : presets[preset];
+    if (typeof raw === "string") {
+      try {
+        raw = JSON.parse(raw);
+      } catch {
+        invalid2("--weights takes a JSON object of component weights");
+      }
+    }
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+      invalid2("--weights takes a JSON object of component weights");
+    const allowed = target === "messages" ? [...MESSAGE_MEASURES, "replies-from-others"] : [
+      ...AUTHOR_MEASURES.filter((name) => name !== "answer-time"),
+      "replies-from-others",
+      "reactions-per-message",
+      "replies-from-others-per-message"
+    ];
+    const entries = Object.entries(raw);
+    for (const [name, weight] of entries) {
+      if (!allowed.includes(name))
+        invalid2(`unknown ${target} score component: ${name}`);
+      if (typeof weight !== "number" || !Number.isFinite(weight) || weight < 0)
+        invalid2(`weight for ${name} must be a finite nonnegative number`);
+    }
+    if (!entries.some(([, weight]) => weight > 0))
+      invalid2("--weights needs at least one positive weight");
+    weights = Object.fromEntries(entries);
+  }
+  const selected = measure ?? (target === "messages" ? "reactions" : "messages");
+  return {
+    target,
+    messageKind,
+    minMessages: minMessages ?? (target === "contacts" && score === "engaging" ? 5 : 1),
+    measure: scoring ? "score" : selected,
+    order: !scoring && selected === "answer-time" ? "ascending" : "descending",
+    weights,
+    preset: scoring ? preset ?? "custom" : null,
+    components: weights === null ? [selected] : Object.entries(weights).filter(([, weight]) => weight > 0).map(([name]) => name)
+  };
+}, "rankingOptions");
+var rankingScore = /* @__PURE__ */ __name((raw, maxima, weights) => {
+  const entries = Object.entries(weights).filter(([, weight]) => weight > 0);
+  const scale = Math.max(...entries.map(([, weight]) => weight));
+  const denominator = entries.reduce((sum2, [, weight]) => sum2 + weight / scale, 0);
+  if (!Number.isFinite(scale) || scale <= 0 || !Number.isFinite(denominator) || denominator <= 0)
+    return null;
+  const normalized = {};
+  const contributions = {};
+  let sum = 0;
+  for (const [name, weight] of entries) {
+    const value = raw[name];
+    const maximum = maxima[name];
+    if (value == null || !Number.isFinite(value) || value < 0 || maximum === void 0 || !Number.isFinite(maximum) || maximum < value)
+      return null;
+    const part = maximum === 0 ? 0 : value / maximum;
+    normalized[name] = part;
+    contributions[name] = 100 * part * (weight / scale) / denominator;
+    sum += contributions[name];
+  }
+  return { score: Math.min(100, sum), normalized, contributions };
+}, "rankingScore");
+var RANKING_TOKENIZER_VERSION = 1;
+var withoutUrls = /* @__PURE__ */ __name((text) => text.replace(/\S+/gu, (token) => {
+  for (let offset = 0; ; ) {
+    const marker = token.indexOf("://", offset);
+    if (marker < 0)
+      break;
+    let start = marker;
+    while (start > 0 && /[a-z0-9+.-]/iu.test(token[start - 1]))
+      start--;
+    if (/^[a-z][a-z0-9+.-]*$/iu.test(token.slice(start, marker)) && (start === 0 || !/\w/u.test(token[start - 1])))
+      return token.slice(0, start);
+    offset = marker + 3;
+  }
+  const folded = token.toLowerCase();
+  for (let offset = 0; ; ) {
+    const start = folded.indexOf("www.", offset);
+    if (start < 0)
+      break;
+    if (start === 0 || !/\w/u.test(token[start - 1]))
+      return token.slice(0, start);
+    offset = start + 4;
+  }
+  return token;
+}), "withoutUrls");
+var rankingWords = /* @__PURE__ */ __name((text) => withoutUrls(text).match(/[\p{L}\p{N}]+/gu)?.length ?? 0, "rankingWords");
+var rankingQuestion = /* @__PURE__ */ __name((text) => withoutUrls(text).includes("?"), "rankingQuestion");
+
+export {
+  KINDS,
+  PROVIDERS,
+  FOLDER_PROVIDERS,
+  isFolderProvider,
+  folderProviderSql,
+  folderProviderOf,
+  DOCUMENT_ACCOUNT_PROVIDERS,
+  isDocumentAccountProvider,
+  filesAccountSql,
+  INTERNAL_NOTES,
+  UNKNOWN_PROVIDER,
+  providerEntryOf,
+  providers,
+  useProviders,
+  useStoredProviders,
+  addProvider,
+  isKind,
+  providerNamed,
+  kindIn,
+  kindOf,
+  formatLocator,
+  isLocator,
+  parseLocator,
+  formatReference,
+  parseReference,
+  canonicalReference,
+  COUNTER_FIELDS,
+  validCounter,
+  counterValue,
+  counterObservationTime,
+  observedCounters,
+  counterFreshness,
+  MESSAGE_MEASURES,
+  AUTHOR_MEASURES,
+  needsRankingContext,
+  rankingOptions,
+  rankingScore,
+  RANKING_TOKENIZER_VERSION,
+  rankingWords,
+  rankingQuestion
+};