@wirecat/cli-core 0.544.0 → 0.546.0

package/dist/domain/ref-arguments.d.ts

@@ -0,0 +1,31 @@
+import { CliError } from "@wirecat/cli-base";
+import type { Id, Provider } from "./models.js";
+/** A `chat:` or `msg:` reference given where a messenger command takes a chat or a message. */
+export interface ChatReference {
+    text: string;
+    provider: Provider;
+    account: Id;
+    chat: Id;
+    message?: Id;
+}
+/** The account a reference must belong to; `account` is `undefined` while this profile's is not known yet. */
+export interface RefScope {
+    account: Id | undefined;
+    profile?: string;
+}
+/** The profiles of this app the store saw on an account; `undefined` when that cannot be told. */
+export type ProfilesOn = (account: Id) => Promise<readonly string[] | undefined>;
+/**
+ * The chat or message a reference names, when `text` is one of this provider's; `undefined` for text that is no
+ * reference, which stays an id or a title. Another kind or another messenger is refused, never read as a title.
+ */
+export declare const chatReferenceOf: (text: string, provider: Provider, takes?: "chat" | "message") => ChatReference | undefined;
+/**
+ * The identity a `contact:` reference names, when it is one of this provider's; `undefined` for any other text. A
+ * `person:` reference is the store's person, which the callers that take one read before this.
+ */
+export declare const contactReferenceOf: (text: string, provider: Provider | undefined) => Id | undefined;
+/** The refusal of another account's reference: switching to it silently would read or send as somebody else. */
+export declare const wrongAccount: (reference: Pick<ChatReference, "text" | "account">, scope: RefScope, profiles?: readonly string[]) => CliError;
+/** Refuses a reference of another account than the scope's, naming the profiles that have it. */
+export declare const ensureAccount: (reference: Pick<ChatReference, "text" | "account">, scope: RefScope, profilesOn?: ProfilesOn) => Promise<void>;

package/dist/domain/ref-arguments.js

@@ -0,0 +1,79 @@
+import { CliError } from "@wirecat/cli-base";
+import { providerLabel, providerNamed } from "./providers.js";
+import { looksLikeReference, parseReference } from "./references.js";
+const TAKES = {
+    chat: "a chat: chat:<provider>/<account>/<chat>, its id or its title",
+    message: "a message: msg:<provider>/<account>/<chat>/<message>, or a chat and the message's id",
+};
+const OPENS = {
+    chat: "messages list",
+    message: "messages show",
+    contact: "contacts show",
+};
+const article = (word) => (/^[aeiou]/.test(word) ? "an" : "a");
+const wrongKind = (text, kind, takes) => new CliError("validation_error", `${text} names ${article(kind)} ${kind}; this takes ${TAKES[takes]}`, {
+    reason: "ref.wrong-kind",
+});
+const wrongProvider = (text, provider, kind) => {
+    const command = providerNamed(provider)?.command;
+    const opens = OPENS[kind];
+    const how = command && opens ? `open it with ${command} <profile> ${opens} ${text}` : "open it with its own CLI";
+    const label = providerLabel(provider);
+    return new CliError("validation_error", `${text} is ${article(label.toLowerCase())} ${label} ${kind}; ${how}`, {
+        reason: "ref.wrong-provider",
+    });
+};
+/**
+ * The chat or message a reference names, when `text` is one of this provider's; `undefined` for text that is no
+ * reference, which stays an id or a title. Another kind or another messenger is refused, never read as a title.
+ */
+export const chatReferenceOf = (text, provider, takes = "chat") => {
+    const trimmed = text.trim();
+    if (!looksLikeReference(trimmed))
+        return undefined;
+    const reference = parseReference(trimmed);
+    if (reference.type !== "chat" && reference.type !== "message")
+        throw wrongKind(trimmed, reference.type, takes);
+    if (reference.provider !== provider)
+        throw wrongProvider(trimmed, reference.provider, reference.type);
+    const found = {
+        text: trimmed,
+        provider: reference.provider,
+        account: reference.account,
+        chat: reference.chat,
+        ...(reference.type === "message" ? { message: reference.message } : {}),
+    };
+    return found;
+};
+/**
+ * The identity a `contact:` reference names, when it is one of this provider's; `undefined` for any other text. A
+ * `person:` reference is the store's person, which the callers that take one read before this.
+ */
+export const contactReferenceOf = (text, provider) => {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("contact:"))
+        return undefined;
+    const reference = parseReference(trimmed);
+    if (reference.type !== "contact")
+        return undefined;
+    if (provider !== undefined && reference.provider !== provider)
+        throw wrongProvider(trimmed, reference.provider, reference.type);
+    return reference.id;
+};
+/** The refusal of another account's reference: switching to it silently would read or send as somebody else. */
+export const wrongAccount = (reference, scope, profiles) => {
+    const here = scope.account === undefined
+        ? "the account of this profile is not known yet"
+        : `${scope.profile === undefined ? "this profile" : `profile ${scope.profile}`} is account ${scope.account}`;
+    const others = profiles === undefined
+        ? ""
+        : `. Profiles signed in to ${reference.account}: ${profiles.length > 0 ? profiles.join(", ") : "none here"}`;
+    return new CliError("validation_error", `${reference.text} belongs to account ${reference.account}; ${here}${others}`, { reason: "ref.wrong-account" });
+};
+/** Refuses a reference of another account than the scope's, naming the profiles that have it. */
+export const ensureAccount = async (reference, scope, profilesOn) => {
+    if (scope.account !== undefined && scope.account === reference.account)
+        return;
+    const profiles = await profilesOn?.(reference.account).catch(() => undefined);
+    throw wrongAccount(reference, scope, profiles);
+};

package/dist/domain/references.d.ts

@@ -1,3 +1,4 @@
+import { type MeetingReference } from "../meetings/index.js";
 /**
  * One typed form for every kind of thing a link, a tag or an argument can name. The prefix makes a
  * wrong kind fail loudly instead of matching another row. Parts that are ids of someone else's system
@@ -27,14 +28,31 @@ export type Reference = {
     type: "folder";
     id: string;
     path: string | null;
-};
+} | MeetingReference;
 /**
  * Things named by their store id (a task also by its key or the task package's id). `entity` is the name
  * before organizations and projects: it still parses, so an old file's reference resolves as not found.
  */
-export declare const SIMPLE_REFERENCES: readonly ["note", "document", "person", "organization", "project", "task", "memory", "fact", "bot", "entity"];
+export declare const SIMPLE_REFERENCES: readonly ["note", "document", "person", "organization", "project", "task", "memory", "fact", "bot", "event", "entity"];
 export type SimpleReference = (typeof SIMPLE_REFERENCES)[number];
+export type RefKindName = Exclude<Reference["type"], "entity">;
+export interface RefKindSpec<R extends Reference = Reference> {
+    /** The word before the first colon: `chat`, `msg`, `document`. */
+    prefix: string;
+    type: R["type"];
+    /** For error texts: `chat:<provider>/<account>/<chat>`. */
+    shape: string;
+    parse(rest: string, text: string): R;
+    format(reference: R): string;
+}
+/** Every kind of reference. A new kind is one row here; nothing else switches on the prefix. */
+export declare const REF_KINDS: readonly RefKindSpec[];
 export declare const formatReference: (reference: Reference) => string;
 export declare const parseReference: (text: string) => Reference;
 /** The stored spelling of a reference, so two spellings of one thing compare equal. */
 export declare const canonicalReference: (text: string) => string;
+/**
+ * Strict: the whole text is one reference of a known kind, with no space. A title such as "Note: plan" is not, so an
+ * argument that takes either a reference or a title can tell them apart. The shape is checked only by parsing it.
+ */
+export declare const looksLikeReference: (text: string) => boolean;

package/dist/domain/references.js

@@ -1,4 +1,5 @@
 import { CliError, singleLine } from "@wirecat/cli-base";
+import { formatMeetingReference, parseMeetingReference } from "../meetings/index.js";
 import { formatLocator, parseLocator } from "./locator.js";
 /**
  * Things named by their store id (a task also by its key or the task package's id). `entity` is the name
@@ -14,70 +15,154 @@ export const SIMPLE_REFERENCES = [
     "memory",
     "fact",
     "bot",
+    "event",
     "entity",
 ];
-const parts = (rest, count, reference, shape) => {
+const malformed = (text, shape) => new CliError("validation_error", `"${singleLine(text)}" is not a reference — expected ${shape}`, {
+    reason: "ref.malformed",
+});
+const parts = (rest, count, text, shape) => {
     const split = rest.split("/");
     if (split.length !== count || split.some((part) => part === ""))
-        throw new CliError("validation_error", `"${singleLine(reference)}" is not a reference — expected ${shape}`);
+        throw malformed(text, shape);
     return split.map(decodeURIComponent);
 };
-export const formatReference = (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}`;
-    }
+const encoded = (...values) => values.map(encodeURIComponent).join("/");
+/** A subfolder spelled one way: no leading, trailing or doubled slash, and `.` for the folder itself. */
+const folderPath = (path) => {
+    const clean = path
+        .split("/")
+        .filter((part) => part !== "" && part !== ".")
+        .join("/");
+    return clean === "" ? (path.trim() === "" ? "" : null) : clean;
 };
-export const parseReference = (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>");
+const MEETING_SHAPE = "meeting:<account>/<meeting>[/<transcript>[/<cue>]] with safe integer ids";
+const kind = (spec) => spec;
+const simple = (prefix) => kind({
+    prefix,
+    type: prefix,
+    shape: `${prefix}:<id>`,
+    parse: (rest, text) => {
+        if (!rest.trim())
+            throw new CliError("validation_error", `"${singleLine(text)}" names no ${prefix}`, {
+                reason: "ref.malformed",
+            });
+        return { type: prefix, id: rest };
+    },
+    format: (reference) => `${reference.type}:${reference.id}`,
+});
+/** Every kind of reference. A new kind is one row here; nothing else switches on the prefix. */
+export const REF_KINDS = [
+    kind({
+        prefix: "msg",
+        type: "message",
+        shape: "msg:<provider>/<account>/<chat>/<message>",
+        parse: (_, text) => {
+            try {
+                return { type: "message", ...parseLocator(text) };
+            }
+            catch {
+                throw malformed(text, "msg:<provider>/<account>/<chat>/<message>");
+            }
+        },
+        format: formatLocator,
+    }),
+    kind({
+        prefix: "chat",
+        type: "chat",
+        shape: "chat:<provider>/<account>/<chat>",
+        parse: (rest, text) => {
+            const [provider, account, chat] = parts(rest, 3, text, "chat:<provider>/<account>/<chat>");
             return { type: "chat", provider, account, chat };
-        }
-        case "contact": {
-            const [provider, id] = parts(rest, 2, reference, "contact:<provider>/<id>");
+        },
+        format: ({ provider, account, chat }) => `chat:${encoded(provider, account, chat)}`,
+    }),
+    kind({
+        prefix: "contact",
+        type: "contact",
+        shape: "contact:<provider>/<id>",
+        parse: (rest, text) => {
+            const [provider, id] = parts(rest, 2, text, "contact:<provider>/<id>");
             return { type: "contact", provider, id };
-        }
-        case "folder": {
+        },
+        format: ({ provider, id }) => `contact:${encoded(provider, id)}`,
+    }),
+    kind({
+        prefix: "folder",
+        type: "folder",
+        shape: "folder:<id>[/<path>]",
+        parse: (rest, text) => {
             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 — expected folder:<id>[/<path>]`);
+                throw malformed(text, "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 };
+        },
+        format: ({ id, path }) => (path === null ? `folder:${encodeURIComponent(id)}` : `folder:${encoded(id, path)}`),
+    }),
+    kind({
+        prefix: "meeting",
+        type: "meeting",
+        shape: MEETING_SHAPE,
+        parse: (_, text) => {
+            try {
+                return parseMeetingReference(text);
             }
-            throw new CliError("validation_error", `"${singleLine(reference)}" is not a reference — expected msg:, chat:, contact:, folder:, ${SIMPLE_REFERENCES.filter((one) => one !== "entity").join(":, ")}:`);
+            catch {
+                throw malformed(text, MEETING_SHAPE);
+            }
+        },
+        format: formatMeetingReference,
+    }),
+    ...SIMPLE_REFERENCES.map(simple),
+];
+const byPrefix = new Map(REF_KINDS.map((spec) => [spec.prefix, spec]));
+const byType = new Map(REF_KINDS.map((spec) => [spec.type, spec]));
+/** The prefixes people are told about: `entity` only still parses. */
+const offered = REF_KINDS.map(({ prefix }) => prefix).filter((prefix) => prefix !== "entity");
+const distance = (a, b) => {
+    let row = Array.from({ length: b.length + 1 }, (_, at) => at);
+    for (const [i, x] of [...a].entries()) {
+        const next = [i + 1];
+        for (const [j, y] of [...b].entries())
+            next.push(Math.min(row[j + 1] + 1, next[j] + 1, row[j] + (x === y ? 0 : 1)));
+        row = next;
     }
+    return row[b.length];
 };
-/** A subfolder spelled one way: no leading, trailing or doubled slash, and `.` for the folder itself. */
-const folderPath = (path) => {
-    const clean = path
-        .split("/")
-        .filter((part) => part !== "" && part !== ".")
-        .join("/");
-    return clean === "" ? (path.trim() === "" ? "" : null) : clean;
+/** `doc` reads as `document`, not as `bot` one letter away: a typed start of a prefix wins over spelling. */
+const nearest = (typed) => offered.find((prefix) => typed.length >= 2 && prefix.startsWith(typed)) ??
+    offered
+        .map((prefix) => ({ prefix, far: distance(typed, prefix) }))
+        .filter(({ far }) => far <= 2)
+        .sort((a, b) => a.far - b.far)[0]?.prefix;
+const unknownKind = (text, prefix, rest) => {
+    const near = prefix === "" ? undefined : nearest(prefix);
+    const kinds = offered.map((one) => `${one}:`).join(", ");
+    const hint = near === undefined ? `; kinds: ${kinds}` : `; did you mean ${near}:${singleLine(rest)}? Kinds: ${kinds}`;
+    return new CliError("validation_error", `"${singleLine(text)}" is no kind of reference${hint}`, {
+        reason: "ref.unknown-kind",
+    });
+};
+export const formatReference = (reference) => byType.get(reference.type).format(reference);
+export const parseReference = (text) => {
+    const reference = text.trim();
+    const colon = reference.indexOf(":");
+    const prefix = colon < 0 ? "" : reference.slice(0, colon);
+    const rest = reference.slice(colon + 1);
+    const spec = byPrefix.get(prefix);
+    if (!spec)
+        throw unknownKind(reference, prefix, rest);
+    return spec.parse(rest, reference);
 };
 /** The stored spelling of a reference, so two spellings of one thing compare equal. */
 export const canonicalReference = (text) => formatReference(parseReference(text));
+/**
+ * Strict: the whole text is one reference of a known kind, with no space. A title such as "Note: plan" is not, so an
+ * argument that takes either a reference or a title can tell them apart. The shape is checked only by parsing it.
+ */
+export const looksLikeReference = (text) => {
+    const match = /^([a-z]+):\S+$/.exec(text.trim());
+    return match !== null && byPrefix.has(match[1]);
+};

package/dist/entities/index.d.ts

@@ -1106,6 +1106,7 @@ export declare const ENTITIES: {
             readonly held: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
             readonly held_chats: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
         }, undefined>, undefined>;
+        readonly history_included: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
     }, undefined>, v.StrictObjectSchema<{
         readonly batch: v.OptionalSchema<v.StrictObjectSchema<{
             readonly attempted: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;

package/dist/entities/message-transfer.d.ts

@@ -209,6 +209,8 @@ export declare const messageSyncChat: v.StrictObjectSchema<{
         readonly held: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
         readonly held_chats: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
     }, undefined>, undefined>;
+    /** `--full-history`: the chat's pushed history is now kept in full; `false` when the store does not know the chat. */
+    readonly history_included: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
 }, undefined>;
 export declare const messageSyncAll: v.StrictObjectSchema<{
     readonly batch: v.OptionalSchema<v.StrictObjectSchema<{
@@ -333,6 +335,8 @@ export declare const messageSync: v.UnionSchema<[v.StrictObjectSchema<{
         readonly held: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
         readonly held_chats: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
     }, undefined>, undefined>;
+    /** `--full-history`: the chat's pushed history is now kept in full; `false` when the store does not know the chat. */
+    readonly history_included: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
 }, undefined>, v.StrictObjectSchema<{
     readonly batch: v.OptionalSchema<v.StrictObjectSchema<{
         readonly attempted: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;

package/dist/entities/message-transfer.js

@@ -60,6 +60,8 @@ export const messageSyncChat = v.strictObject({
     reached_last: v.optional(v.literal(true)),
     stopped: v.optional(v.literal(true)),
     tasks,
+    /** `--full-history`: the chat's pushed history is now kept in full; `false` when the store does not know the chat. */
+    history_included: v.optional(v.boolean()),
 });
 export const messageSyncAll = v.strictObject({
     batch: v.optional(batchResult),

package/dist/errors/reasons.js

@@ -29,6 +29,8 @@ const SIGN_IN = [
     ["oauth.revoke-failed", "outcome_unknown", "the provider did not confirm the revoke"],
     ["oauth.invalid", "authentication_error", "the saved sign-in cannot be read"],
     ["oauth.not-saved", "configuration_error", "the sign-in cannot be saved or read where it is kept"],
+    ["sign-in.client-file-open", "configuration_error", "other users of this computer can read the client file"],
+    ["sign-in.client-file-invalid", "configuration_error", "the file is not a Desktop app OAuth client JSON"],
 ];
 const OTHERS = [
     ["model.offline", "permission_error", "downloading a model needs the network; --offline was requested"],
@@ -78,6 +80,17 @@ const OTHERS = [
     validation("ics.too-many", "the file holds more events than one import sends"),
     validation("ics.too-large", "the file is larger than one import reads"),
     ["calendar.read-only", "permission_error", "the calendar takes no new events from this account"],
+    validation("feed.address-invalid", "a feed address is an http, https or webcal URL with no user or password in it"),
+    validation("feed.duplicate", "this profile follows a feed at this address already"),
+    validation("feed.not-a-feed", "the calendar is not a feed this profile follows"),
+    validation("feed.too-large", "the feed is larger than one sync reads"),
+    validation("feed.redirect-refused", "the feed sent the request on to an address that is not https"),
+    ["feed.no-address", "configuration_error", "the feed's address is no longer kept on this computer"],
+    ["feed.refused", "provider_error", "the feed's server refused the request"],
+    ["feed.gone", "not_found", "the feed's server has no feed at this address any more"],
+    ["feed.timeout", "timeout", "the feed's server did not answer in time"],
+    ["feed.unreachable", "network_error", "the feed's server could not be reached"],
+    validation("busy.feed", "a feed calendar has no busy times to ask; read its events with events list"),
     ["calendar.unsynced", "not_found", "the calendar account has no synced calendar in the store"],
     ["calendar.sync-incomplete", "not_found", "a synced calendar's sync never finished or is mid-round"],
     ["calendar.no-upcoming", "not_found", "no upcoming meeting with other attendees is stored for this account"],
@@ -133,6 +146,11 @@ const OTHERS = [
     validation("period.ambiguous", "the period can be read more than one way"),
     validation("proposal.wrong-state", "the proposal is not in a state that allows this"),
     validation("ranking.invalid", "the ranking is not valid"),
+    validation("ref.malformed", "the reference has a known kind but not its shape"),
+    validation("ref.unknown-kind", "the text names no kind of reference"),
+    validation("ref.wrong-kind", "the reference names another kind of thing than the argument takes"),
+    validation("ref.wrong-provider", "the reference belongs to another messenger; open it with that CLI"),
+    validation("ref.wrong-account", "the reference belongs to another account than this profile's"),
     validation("selection.changed", "the stored selection changed meanwhile"),
     validation("selection.invalid", "the selection is not valid"),
     validation("search.kind", "the saved search belongs to another kind of search: messages or meetings"),

package/dist/index.d.ts

@@ -12,7 +12,7 @@ export { FOLDER_PROVIDERS, isFolderProvider, isKind, KINDS, type Kind, kindIn, k
 export type { RankingGraphEvidence, RankingGraphLink } from "./domain/rankings-graph.js";
 export type { RankingComponent, RankingInput, RankingMeasure, RankingOptions, RankingTarget, RankingWeights, ScorePreset, } from "./domain/rankings-options.js";
 export { rankingOptions } from "./domain/rankings-options.js";
-export { canonicalReference, formatReference, parseReference, type Reference } from "./domain/references.js";
+export { canonicalReference, formatReference, looksLikeReference, parseReference, REF_KINDS, type Reference, type RefKindName, type RefKindSpec, } from "./domain/references.js";
 export { normalizeTag, TAG_TYPES, type TagType } from "./domain/tags.js";
 export { type AppErrors, DETAILS as CORE_DETAILS, failureContext, REASONS as CORE_REASONS } from "./errors/reasons.js";
 export { canonicalMeetingReference, formatMeetingReference, type MeetingReference, parseMeetingReference, } from "./meetings/index.js";

package/dist/index.js

@@ -7,7 +7,7 @@ export { parseMarkdownSpans } from "./domain/markdown-spans.js";
 export { countedPoll } from "./domain/polls.js";
 export { FOLDER_PROVIDERS, isFolderProvider, isKind, KINDS, kindIn, kindOf, PROVIDERS, providerNamed, providers, UNKNOWN_PROVIDER, useProviders, } from "./domain/providers.js";
 export { rankingOptions } from "./domain/rankings-options.js";
-export { canonicalReference, formatReference, parseReference } from "./domain/references.js";
+export { canonicalReference, formatReference, looksLikeReference, parseReference, REF_KINDS, } from "./domain/references.js";
 export { normalizeTag, TAG_TYPES } from "./domain/tags.js";
 export { DETAILS as CORE_DETAILS, failureContext, REASONS as CORE_REASONS } from "./errors/reasons.js";
 export { canonicalMeetingReference, formatMeetingReference, parseMeetingReference, } from "./meetings/index.js";