@aglyn/aglyn 1.0.0-beta.198 → 1.0.0-beta.200

package/src/lib/app-utils/artifact-list-keys.js

@@ -0,0 +1,144 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { displayNameSearchFields } from "./name-search.js";
+/*
+ * THE KEYS A SITE ARTIFACT'S LISTS QUERY BY (AGL-3321).
+ *
+ * The screens, layouts, reusable components and templates of a site are
+ * listed, searched and filtered by Firestore queries, so every key a list
+ * asks about has to be WRITTEN — a query cannot find a document by a value it
+ * derives, and cannot find one that lacks the field at all:
+ *
+ *   nameLower / nameTokens / nameReversed
+ *                the name keys (`displayNameSearchFields`), on all four;
+ *   kind         on a component, `site` or `email` — a component stored
+ *                before AGL-3287 carries none and is read as `site`, so the
+ *                "Used in: Page" filter needs the word stored;
+ *                on a template, `page`, `component` or `layout` — a template
+ *                stored with none is read as a page template;
+ *   source.type  on a template, its provenance — one stored with no
+ *                `source`, or with the legacy `workspace`, was saved here,
+ *                which is `authored`;
+ *   libraryRow   on a template, whether it is its own row of the templates
+ *                library: a multi-page STARTER is one row (AGL-696), led by
+ *                its first live page, so the other pages carry `false` — and
+ *                so does a deleted template (`artifactDeleteListKeys`), which
+ *                is how the library's query leaves tombstones out;
+ *
+ * A DELETED screen gets none of them. The email templates list orders by
+ * `nameLower`, and an email template's delete clears its name keys so the
+ * tombstone leaves that order (a query cannot ask for `deletedAt` to be
+ * absent) — so no create, restore or backfill may stamp them back.
+ *
+ * Every CREATE stamps them (`artifactCreateListKeys`) and every rename
+ * restamps the name keys (`artifactRenameListKeys`).
+ * `tools/scripts/backfill-artifacts-list-keys.mjs` stamps the documents
+ * written before them; a script cannot import this library, so it reads the
+ * documents the way this module does, and both sides answer
+ * `tools/scripts/lib/artifact-list-keys.fixtures.json` — this module's spec
+ * and the backfill's `--self-test`.
+ */ /** The site artifact collections whose lists query these keys. */ export const LISTED_ARTIFACT_COLLECTIONS = [
+    'screens',
+    'layouts',
+    'components',
+    'templates'
+];
+/** Whether a host subcollection is one whose lists query these keys. */ export const isListedArtifactCollection = (collection)=>LISTED_ARTIFACT_COLLECTIONS.includes(collection);
+/** The kinds a template's `kind` holds; absent reads as `page`. */ const TEMPLATE_KINDS = [
+    'page',
+    'component',
+    'layout'
+];
+/**
+ * A provenance word no writer stores any more: a detached marketplace copy
+ * was stamped `workspace` before it was stamped `authored` (AGL-3321).
+ */ const LEGACY_AUTHORED_SOURCE = 'workspace';
+const record = (value)=>value && typeof value === 'object' ? value : {};
+/**
+ * The name a list finds an artifact by.
+ *
+ * Its `displayName` — except a page of a multi-page STARTER, which the
+ * templates library lists as ONE row under the starter's name
+ * (`source.starterName`), so every page of it carries that name's keys and a
+ * search for the starter finds the row whichever page leads it.
+ */ export function artifactSearchName(collection, doc) {
+    if (collection === 'templates') {
+        const starterName = record(doc['source'])['starterName'];
+        if (typeof starterName === 'string' && starterName.trim()) return starterName;
+    }
+    return doc['displayName'];
+}
+/**
+ * The list keys a CREATE of `doc` into `collection` stamps: the name keys,
+ * and the stored default of a kind a reader otherwise infers. Nothing for a
+ * collection no artifact list queries.
+ *
+ * Spread AFTER the document's own fields: the keys are derived from them.
+ */ export function artifactCreateListKeys(collection, doc) {
+    if (!isListedArtifactCollection(collection)) return {};
+    if (collection === 'screens' && doc['deletedAt'] != null) return {};
+    const keys = _extends({}, displayNameSearchFields(artifactSearchName(collection, doc)));
+    if (collection === 'components' && doc['kind'] !== 'email') keys['kind'] = 'site';
+    if (collection === 'templates') {
+        if (!TEMPLATE_KINDS.includes(String(doc['kind']))) keys['kind'] = 'page';
+        // Provenance is server-managed (AGL-666), and a writer that states it is
+        // never overridden here. None at all, or the legacy word a detached copy
+        // carried, was saved here, which is `authored`.
+        const sourceType = record(doc['source'])['type'];
+        if (typeof sourceType !== 'string' || sourceType === LEGACY_AUTHORED_SOURCE) {
+            keys['source'] = _extends({}, record(doc['source']), {
+                type: 'authored'
+            });
+        }
+        keys['libraryRow'] = doc['deletedAt'] == null && leadsItsStarter(doc);
+    }
+    return keys;
+}
+/**
+ * Whether a template leads its starter's library row when the starter is
+ * written whole: every template that is not a starter page does, and of a
+ * starter's pages the first (`starterOrder` 0). A later delete moves the lead
+ * to the next live page — see `artifactDeleteListKeys`.
+ */ function leadsItsStarter(doc) {
+    var _source_starterOrder;
+    const source = record(doc['source']);
+    const starterId = source['starterId'];
+    if (typeof starterId !== 'string' || !starterId) return true;
+    return Number((_source_starterOrder = source['starterOrder']) != null ? _source_starterOrder : 0) === 0;
+}
+/**
+ * The list keys a SOFT DELETE writes beside `deletedAt`: a deleted template
+ * is no longer a library row. A caller deleting the page that LEADS a
+ * starter's row gives the lead to the next live page (`libraryRow: true`),
+ * or the starter disappears from the library with pages still in it.
+ */ export function artifactDeleteListKeys(collection) {
+    return collection === 'templates' ? {
+        libraryRow: false
+    } : {};
+}
+/**
+ * The name keys a RENAME writes beside the new `displayName`. `doc` is the
+ * document as read, for the one case whose search name is not its display
+ * name (a starter page — see `artifactSearchName`).
+ */ export function artifactRenameListKeys(collection, displayName, doc = {}) {
+    if (!isListedArtifactCollection(collection)) return {};
+    return displayNameSearchFields(artifactSearchName(collection, _extends({}, doc, {
+        displayName
+    })));
+}
+
+//# sourceMappingURL=artifact-list-keys.js.map

package/src/lib/app-utils/artifact-list-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/artifact-list-keys.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { displayNameSearchFields } from './name-search'\n\n/*\n * THE KEYS A SITE ARTIFACT'S LISTS QUERY BY (AGL-3321).\n *\n * The screens, layouts, reusable components and templates of a site are\n * listed, searched and filtered by Firestore queries, so every key a list\n * asks about has to be WRITTEN — a query cannot find a document by a value it\n * derives, and cannot find one that lacks the field at all:\n *\n *   nameLower / nameTokens / nameReversed\n *                the name keys (`displayNameSearchFields`), on all four;\n *   kind         on a component, `site` or `email` — a component stored\n *                before AGL-3287 carries none and is read as `site`, so the\n *                \"Used in: Page\" filter needs the word stored;\n *                on a template, `page`, `component` or `layout` — a template\n *                stored with none is read as a page template;\n *   source.type  on a template, its provenance — one stored with no\n *                `source`, or with the legacy `workspace`, was saved here,\n *                which is `authored`;\n *   libraryRow   on a template, whether it is its own row of the templates\n *                library: a multi-page STARTER is one row (AGL-696), led by\n *                its first live page, so the other pages carry `false` — and\n *                so does a deleted template (`artifactDeleteListKeys`), which\n *                is how the library's query leaves tombstones out;\n *\n * A DELETED screen gets none of them. The email templates list orders by\n * `nameLower`, and an email template's delete clears its name keys so the\n * tombstone leaves that order (a query cannot ask for `deletedAt` to be\n * absent) — so no create, restore or backfill may stamp them back.\n *\n * Every CREATE stamps them (`artifactCreateListKeys`) and every rename\n * restamps the name keys (`artifactRenameListKeys`).\n * `tools/scripts/backfill-artifacts-list-keys.mjs` stamps the documents\n * written before them; a script cannot import this library, so it reads the\n * documents the way this module does, and both sides answer\n * `tools/scripts/lib/artifact-list-keys.fixtures.json` — this module's spec\n * and the backfill's `--self-test`.\n */\n\n/** The site artifact collections whose lists query these keys. */\nexport const LISTED_ARTIFACT_COLLECTIONS = [\n  'screens',\n  'layouts',\n  'components',\n  'templates',\n] as const\n\nexport type ListedArtifactCollection =\n  (typeof LISTED_ARTIFACT_COLLECTIONS)[number]\n\n/** Whether a host subcollection is one whose lists query these keys. */\nexport const isListedArtifactCollection = (\n  collection: string,\n): collection is ListedArtifactCollection =>\n  (LISTED_ARTIFACT_COLLECTIONS as readonly string[]).includes(collection)\n\n/** The kinds a template's `kind` holds; absent reads as `page`. */\nconst TEMPLATE_KINDS = ['page', 'component', 'layout']\n\n/**\n * A provenance word no writer stores any more: a detached marketplace copy\n * was stamped `workspace` before it was stamped `authored` (AGL-3321).\n */\nconst LEGACY_AUTHORED_SOURCE = 'workspace'\n\nconst record = (value: unknown): Record<string, unknown> =>\n  value && typeof value === 'object' ? (value as Record<string, unknown>) : {}\n\n/**\n * The name a list finds an artifact by.\n *\n * Its `displayName` — except a page of a multi-page STARTER, which the\n * templates library lists as ONE row under the starter's name\n * (`source.starterName`), so every page of it carries that name's keys and a\n * search for the starter finds the row whichever page leads it.\n */\nexport function artifactSearchName(\n  collection: string,\n  doc: Record<string, unknown>,\n): unknown {\n  if (collection === 'templates') {\n    const starterName = record(doc['source'])['starterName']\n    if (typeof starterName === 'string' && starterName.trim()) return starterName\n  }\n  return doc['displayName']\n}\n\n/**\n * The list keys a CREATE of `doc` into `collection` stamps: the name keys,\n * and the stored default of a kind a reader otherwise infers. Nothing for a\n * collection no artifact list queries.\n *\n * Spread AFTER the document's own fields: the keys are derived from them.\n */\nexport function artifactCreateListKeys(\n  collection: string,\n  doc: Record<string, unknown>,\n): Record<string, unknown> {\n  if (!isListedArtifactCollection(collection)) return {}\n  if (collection === 'screens' && doc['deletedAt'] != null) return {}\n  const keys: Record<string, unknown> = {\n    ...displayNameSearchFields(artifactSearchName(collection, doc)),\n  }\n  if (collection === 'components' && doc['kind'] !== 'email') keys['kind'] = 'site'\n  if (collection === 'templates') {\n    if (!TEMPLATE_KINDS.includes(String(doc['kind']))) keys['kind'] = 'page'\n    // Provenance is server-managed (AGL-666), and a writer that states it is\n    // never overridden here. None at all, or the legacy word a detached copy\n    // carried, was saved here, which is `authored`.\n    const sourceType = record(doc['source'])['type']\n    if (typeof sourceType !== 'string' || sourceType === LEGACY_AUTHORED_SOURCE) {\n      keys['source'] = { ...record(doc['source']), type: 'authored' }\n    }\n    keys['libraryRow'] = doc['deletedAt'] == null && leadsItsStarter(doc)\n  }\n  return keys\n}\n\n/**\n * Whether a template leads its starter's library row when the starter is\n * written whole: every template that is not a starter page does, and of a\n * starter's pages the first (`starterOrder` 0). A later delete moves the lead\n * to the next live page — see `artifactDeleteListKeys`.\n */\nfunction leadsItsStarter(doc: Record<string, unknown>): boolean {\n  const source = record(doc['source'])\n  const starterId = source['starterId']\n  if (typeof starterId !== 'string' || !starterId) return true\n  return Number(source['starterOrder'] ?? 0) === 0\n}\n\n/**\n * The list keys a SOFT DELETE writes beside `deletedAt`: a deleted template\n * is no longer a library row. A caller deleting the page that LEADS a\n * starter's row gives the lead to the next live page (`libraryRow: true`),\n * or the starter disappears from the library with pages still in it.\n */\nexport function artifactDeleteListKeys(\n  collection: string,\n): Record<string, unknown> {\n  return collection === 'templates' ? { libraryRow: false } : {}\n}\n\n/**\n * The name keys a RENAME writes beside the new `displayName`. `doc` is the\n * document as read, for the one case whose search name is not its display\n * name (a starter page — see `artifactSearchName`).\n */\nexport function artifactRenameListKeys(\n  collection: string,\n  displayName: unknown,\n  doc: Record<string, unknown> = {},\n): Record<string, unknown> {\n  if (!isListedArtifactCollection(collection)) return {}\n  return displayNameSearchFields(\n    artifactSearchName(collection, { ...doc, displayName }),\n  )\n}\n"],"names":["displayNameSearchFields","LISTED_ARTIFACT_COLLECTIONS","isListedArtifactCollection","collection","includes","TEMPLATE_KINDS","LEGACY_AUTHORED_SOURCE","record","value","artifactSearchName","doc","starterName","trim","artifactCreateListKeys","keys","String","sourceType","type","leadsItsStarter","source","starterId","Number","artifactDeleteListKeys","libraryRow","artifactRenameListKeys","displayName"],"mappings":";AAAA;;;;;;;;;;;;;;;CAeC,GAED,SAASA,uBAAuB,QAAQ,mBAAe;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCC,GAED,gEAAgE,GAChE,OAAO,MAAMC,8BAA8B;IACzC;IACA;IACA;IACA;CACD,CAAS;AAKV,sEAAsE,GACtE,OAAO,MAAMC,6BAA6B,CACxCC,aAEA,AAACF,4BAAkDG,QAAQ,CAACD,YAAW;AAEzE,iEAAiE,GACjE,MAAME,iBAAiB;IAAC;IAAQ;IAAa;CAAS;AAEtD;;;CAGC,GACD,MAAMC,yBAAyB;AAE/B,MAAMC,SAAS,CAACC,QACdA,SAAS,OAAOA,UAAU,WAAYA,QAAoC,CAAC;AAE7E;;;;;;;CAOC,GACD,OAAO,SAASC,mBACdN,UAAkB,EAClBO,GAA4B;IAE5B,IAAIP,eAAe,aAAa;QAC9B,MAAMQ,cAAcJ,OAAOG,GAAG,CAAC,SAAS,CAAC,CAAC,cAAc;QACxD,IAAI,OAAOC,gBAAgB,YAAYA,YAAYC,IAAI,IAAI,OAAOD;IACpE;IACA,OAAOD,GAAG,CAAC,cAAc;AAC3B;AAEA;;;;;;CAMC,GACD,OAAO,SAASG,uBACdV,UAAkB,EAClBO,GAA4B;IAE5B,IAAI,CAACR,2BAA2BC,aAAa,OAAO,CAAC;IACrD,IAAIA,eAAe,aAAaO,GAAG,CAAC,YAAY,IAAI,MAAM,OAAO,CAAC;IAClE,MAAMI,OAAgC,aACjCd,wBAAwBS,mBAAmBN,YAAYO;IAE5D,IAAIP,eAAe,gBAAgBO,GAAG,CAAC,OAAO,KAAK,SAASI,IAAI,CAAC,OAAO,GAAG;IAC3E,IAAIX,eAAe,aAAa;QAC9B,IAAI,CAACE,eAAeD,QAAQ,CAACW,OAAOL,GAAG,CAAC,OAAO,IAAII,IAAI,CAAC,OAAO,GAAG;QAClE,yEAAyE;QACzE,yEAAyE;QACzE,gDAAgD;QAChD,MAAME,aAAaT,OAAOG,GAAG,CAAC,SAAS,CAAC,CAAC,OAAO;QAChD,IAAI,OAAOM,eAAe,YAAYA,eAAeV,wBAAwB;YAC3EQ,IAAI,CAAC,SAAS,GAAG,aAAKP,OAAOG,GAAG,CAAC,SAAS;gBAAGO,MAAM;;QACrD;QACAH,IAAI,CAAC,aAAa,GAAGJ,GAAG,CAAC,YAAY,IAAI,QAAQQ,gBAAgBR;IACnE;IACA,OAAOI;AACT;AAEA;;;;;CAKC,GACD,SAASI,gBAAgBR,GAA4B;QAIrCS;IAHd,MAAMA,SAASZ,OAAOG,GAAG,CAAC,SAAS;IACnC,MAAMU,YAAYD,MAAM,CAAC,YAAY;IACrC,IAAI,OAAOC,cAAc,YAAY,CAACA,WAAW,OAAO;IACxD,OAAOC,QAAOF,uBAAAA,MAAM,CAAC,eAAe,YAAtBA,uBAA0B,OAAO;AACjD;AAEA;;;;;CAKC,GACD,OAAO,SAASG,uBACdnB,UAAkB;IAElB,OAAOA,eAAe,cAAc;QAAEoB,YAAY;IAAM,IAAI,CAAC;AAC/D;AAEA;;;;CAIC,GACD,OAAO,SAASC,uBACdrB,UAAkB,EAClBsB,WAAoB,EACpBf,MAA+B,CAAC,CAAC;IAEjC,IAAI,CAACR,2BAA2BC,aAAa,OAAO,CAAC;IACrD,OAAOH,wBACLS,mBAAmBN,YAAY,aAAKO;QAAKe;;AAE7C"}

package/src/lib/app-utils/content-query-fields.d.ts

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * The field the console's entries table searches (AGL-3321): every word
+ * prefix of the entry's title, as `nameSearchTokens` writes them, which the
+ * table's quick search and its Title "contains" filter ask with
+ * `array-contains` on the Firestore query.
+ *
+ * DERIVED, and never carried in a bundle. Every writer of `title` stamps it
+ * through {@link entryTitleSearchFields}: the entry editor's save, the
+ * resources route's create, the bundle import, and the seed and changelog
+ * scripts. `tools/scripts/backfill-entries-title-tokens.mjs` stamps the
+ * entries written before it. An entry without it still lists; it just cannot
+ * be found by a word of its title.
+ */
+export declare const ENTRY_TITLE_TOKENS_FIELD = "titleTokens";
+/**
+ * The search half of a write that sets an entry's `title`. An entry with no
+ * title gets an empty array, so the field is present on every entry and the
+ * backfill has nothing left to find.
+ */
+export declare function entryTitleSearchFields(title: unknown): {
+    [ENTRY_TITLE_TOKENS_FIELD]: string[];
+};
+/**
+ * Where an author's schema type is stored as the WORD the console's Authors
+ * table filters by (AGL-3321).
+ *
+ * `type` holds `HostEntityType` in whichever spelling wrote it: the number
+ * from the authors tab, a string `"1"`/`"2"` from an older bundle, nothing at
+ * all on a record `contentAuthorSchemaType` reads as `Organization`. A query
+ * matches one stored value, so an equality on `type` would miss every record
+ * spelled another way. This field is that one value.
+ */
+export declare const AUTHOR_SCHEMA_TYPE_FIELD = "schemaType";
+/**
+ * The fields the Authors table's query reads (AGL-3321), derived from what the
+ * record already says: the name's lower-cased key and word-prefix tokens,
+ * normalized exactly as `nameSearchKey` / `nameSearchTokens` normalize a typed
+ * value, and the schema type as the row reads it.
+ *
+ * Spread at EVERY write of an author's `name` or `type` — the resources
+ * route's create, the authors tab's edit, the bundle import — and stamped on
+ * older records by `tools/scripts/backfill-authors-search-fields.mjs`. A
+ * record without them still reaches the picker, which reads every author; it
+ * is only the table's filters and search that cannot see it.
+ */
+export declare function contentAuthorQueryFields(author: {
+    name?: unknown;
+    type?: unknown;
+}): {
+    nameLower: string;
+    nameTokens: string[];
+    [AUTHOR_SCHEMA_TYPE_FIELD]: 'Person' | 'Organization';
+};

package/src/lib/app-utils/content-query-fields.js

@@ -0,0 +1,79 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { contentAuthorSchemaType } from "./content-authors.js";
+import { nameSearchKey, nameSearchTokens } from "./name-search.js";
+/*
+ * The fields the console's content tables QUERY, stamped by the writes that
+ * set an entry's title or an author's name (AGL-3321).
+ *
+ * ⛔ Kept apart from `collection-entries` and `content-authors`. Those two are
+ * read by the compose pipeline, so whatever they import ships in the site
+ * runtime a published page loads (`check:tenant-wire-weight`). These helpers
+ * are only ever called by the console and its routes, and `name-search` has
+ * no business on a customer's page.
+ */ /**
+ * The field the console's entries table searches (AGL-3321): every word
+ * prefix of the entry's title, as `nameSearchTokens` writes them, which the
+ * table's quick search and its Title "contains" filter ask with
+ * `array-contains` on the Firestore query.
+ *
+ * DERIVED, and never carried in a bundle. Every writer of `title` stamps it
+ * through {@link entryTitleSearchFields}: the entry editor's save, the
+ * resources route's create, the bundle import, and the seed and changelog
+ * scripts. `tools/scripts/backfill-entries-title-tokens.mjs` stamps the
+ * entries written before it. An entry without it still lists; it just cannot
+ * be found by a word of its title.
+ */ export const ENTRY_TITLE_TOKENS_FIELD = 'titleTokens';
+/**
+ * The search half of a write that sets an entry's `title`. An entry with no
+ * title gets an empty array, so the field is present on every entry and the
+ * backfill has nothing left to find.
+ */ export function entryTitleSearchFields(title) {
+    return {
+        [ENTRY_TITLE_TOKENS_FIELD]: nameSearchTokens(typeof title === 'string' ? title : '')
+    };
+}
+/**
+ * Where an author's schema type is stored as the WORD the console's Authors
+ * table filters by (AGL-3321).
+ *
+ * `type` holds `HostEntityType` in whichever spelling wrote it: the number
+ * from the authors tab, a string `"1"`/`"2"` from an older bundle, nothing at
+ * all on a record `contentAuthorSchemaType` reads as `Organization`. A query
+ * matches one stored value, so an equality on `type` would miss every record
+ * spelled another way. This field is that one value.
+ */ export const AUTHOR_SCHEMA_TYPE_FIELD = 'schemaType';
+/**
+ * The fields the Authors table's query reads (AGL-3321), derived from what the
+ * record already says: the name's lower-cased key and word-prefix tokens,
+ * normalized exactly as `nameSearchKey` / `nameSearchTokens` normalize a typed
+ * value, and the schema type as the row reads it.
+ *
+ * Spread at EVERY write of an author's `name` or `type` — the resources
+ * route's create, the authors tab's edit, the bundle import — and stamped on
+ * older records by `tools/scripts/backfill-authors-search-fields.mjs`. A
+ * record without them still reaches the picker, which reads every author; it
+ * is only the table's filters and search that cannot see it.
+ */ export function contentAuthorQueryFields(author) {
+    const name = typeof author.name === 'string' ? author.name : '';
+    return {
+        nameLower: nameSearchKey(name),
+        nameTokens: nameSearchTokens(name),
+        [AUTHOR_SCHEMA_TYPE_FIELD]: contentAuthorSchemaType(author.type)
+    };
+}
+
+//# sourceMappingURL=content-query-fields.js.map

package/src/lib/app-utils/content-query-fields.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/content-query-fields.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { contentAuthorSchemaType } from './content-authors'\nimport type { HostEntityType } from '../foundation/definitions/platform.types'\nimport { nameSearchKey, nameSearchTokens } from './name-search'\n\n/*\n * The fields the console's content tables QUERY, stamped by the writes that\n * set an entry's title or an author's name (AGL-3321).\n *\n * ⛔ Kept apart from `collection-entries` and `content-authors`. Those two are\n * read by the compose pipeline, so whatever they import ships in the site\n * runtime a published page loads (`check:tenant-wire-weight`). These helpers\n * are only ever called by the console and its routes, and `name-search` has\n * no business on a customer's page.\n */\n\n/**\n * The field the console's entries table searches (AGL-3321): every word\n * prefix of the entry's title, as `nameSearchTokens` writes them, which the\n * table's quick search and its Title \"contains\" filter ask with\n * `array-contains` on the Firestore query.\n *\n * DERIVED, and never carried in a bundle. Every writer of `title` stamps it\n * through {@link entryTitleSearchFields}: the entry editor's save, the\n * resources route's create, the bundle import, and the seed and changelog\n * scripts. `tools/scripts/backfill-entries-title-tokens.mjs` stamps the\n * entries written before it. An entry without it still lists; it just cannot\n * be found by a word of its title.\n */\nexport const ENTRY_TITLE_TOKENS_FIELD = 'titleTokens'\n\n/**\n * The search half of a write that sets an entry's `title`. An entry with no\n * title gets an empty array, so the field is present on every entry and the\n * backfill has nothing left to find.\n */\nexport function entryTitleSearchFields(title: unknown): {\n  [ENTRY_TITLE_TOKENS_FIELD]: string[]\n} {\n  return {\n    [ENTRY_TITLE_TOKENS_FIELD]: nameSearchTokens(\n      typeof title === 'string' ? title : '',\n    ),\n  }\n}\n\n/**\n * Where an author's schema type is stored as the WORD the console's Authors\n * table filters by (AGL-3321).\n *\n * `type` holds `HostEntityType` in whichever spelling wrote it: the number\n * from the authors tab, a string `\"1\"`/`\"2\"` from an older bundle, nothing at\n * all on a record `contentAuthorSchemaType` reads as `Organization`. A query\n * matches one stored value, so an equality on `type` would miss every record\n * spelled another way. This field is that one value.\n */\nexport const AUTHOR_SCHEMA_TYPE_FIELD = 'schemaType'\n\n/**\n * The fields the Authors table's query reads (AGL-3321), derived from what the\n * record already says: the name's lower-cased key and word-prefix tokens,\n * normalized exactly as `nameSearchKey` / `nameSearchTokens` normalize a typed\n * value, and the schema type as the row reads it.\n *\n * Spread at EVERY write of an author's `name` or `type` — the resources\n * route's create, the authors tab's edit, the bundle import — and stamped on\n * older records by `tools/scripts/backfill-authors-search-fields.mjs`. A\n * record without them still reaches the picker, which reads every author; it\n * is only the table's filters and search that cannot see it.\n */\nexport function contentAuthorQueryFields(author: {\n  name?: unknown\n  type?: unknown\n}): {\n  nameLower: string\n  nameTokens: string[]\n  [AUTHOR_SCHEMA_TYPE_FIELD]: 'Person' | 'Organization'\n} {\n  const name = typeof author.name === 'string' ? author.name : ''\n  return {\n    nameLower: nameSearchKey(name),\n    nameTokens: nameSearchTokens(name),\n    [AUTHOR_SCHEMA_TYPE_FIELD]: contentAuthorSchemaType(\n      author.type as HostEntityType | string | number | undefined | null,\n    ),\n  }\n}\n"],"names":["contentAuthorSchemaType","nameSearchKey","nameSearchTokens","ENTRY_TITLE_TOKENS_FIELD","entryTitleSearchFields","title","AUTHOR_SCHEMA_TYPE_FIELD","contentAuthorQueryFields","author","name","nameLower","nameTokens","type"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED,SAASA,uBAAuB,QAAQ,uBAAmB;AAE3D,SAASC,aAAa,EAAEC,gBAAgB,QAAQ,mBAAe;AAE/D;;;;;;;;;CASC,GAED;;;;;;;;;;;;CAYC,GACD,OAAO,MAAMC,2BAA2B,cAAa;AAErD;;;;CAIC,GACD,OAAO,SAASC,uBAAuBC,KAAc;IAGnD,OAAO;QACL,CAACF,yBAAyB,EAAED,iBAC1B,OAAOG,UAAU,WAAWA,QAAQ;IAExC;AACF;AAEA;;;;;;;;;CASC,GACD,OAAO,MAAMC,2BAA2B,aAAY;AAEpD;;;;;;;;;;;CAWC,GACD,OAAO,SAASC,yBAAyBC,MAGxC;IAKC,MAAMC,OAAO,OAAOD,OAAOC,IAAI,KAAK,WAAWD,OAAOC,IAAI,GAAG;IAC7D,OAAO;QACLC,WAAWT,cAAcQ;QACzBE,YAAYT,iBAAiBO;QAC7B,CAACH,yBAAyB,EAAEN,wBAC1BQ,OAAOI,IAAI;IAEf;AACF"}

package/src/lib/app-utils/crm.d.ts

@@ -47,7 +47,7 @@ import { type AglynPostalAddress, type OrgCrmAssignmentRule } from '../foundatio
 import { type ConsentGroup } from './consent-groups';
 import { type ContactLifecycleStage, type CrmActivityKind, type CrmTaskKind } from './crm-kinds';
 import { type ContactInteraction, type ContactSegment, type ContactSource } from './contacts';
-import type { EmailState } from './email-state';
+import { type EmailState } from './email-state';
 import { type ScopeToken } from './scope-tokens';
 export * from './crm-kinds';
 /**
@@ -1769,3 +1769,153 @@ export declare const CRM_MEDIA_IDS_MAX = 20;
  * that names its current location.
  */
 export declare function normalizeCrmMediaIds(value: unknown): string[];
+/** The search box's word-prefix tokens, on every CRM record a list searches. */
+export declare const CRM_SEARCH_TOKENS_FIELD = "searchTokens";
+/** The same tokens behind each `visibleTo` token — see the block header. */
+export declare const CRM_SCOPED_SEARCH_TOKENS_FIELD = "scopedSearchTokens";
+/** What joins a scope token to a search token — the platform's one join (`SCOPED_SEARCH_JOIN`). */
+export declare const CRM_SCOPED_SEARCH_JOIN = "~";
+/**
+ * The most search tokens one record keeps. A name, an address, a company
+ * and a title are a few dozen prefixes; the cap is what keeps a record with
+ * twenty long tags from spending hundreds of index entries on them.
+ */
+export declare const CRM_SEARCH_TOKENS_MAX = 200;
+/** The collections whose lists query the fields below. */
+export type CrmListCollection = 'leads' | 'contacts' | 'companies' | 'deals' | 'crmTasks';
+/**
+ * The word-prefix tokens of several values, merged: every prefix (up to
+ * twelve characters) of every whitespace-separated word, lower-cased —
+ * exactly `nameSearchTokens` per value — plus, for an email address, the
+ * words it is made of, so `acme` finds `dana@acme.com` and `dana` does too.
+ */
+export declare function crmSearchTokens(values: readonly unknown[]): string[];
+/**
+ * The two search fields for a record whose search reads `values`: the
+ * tokens, and the same tokens behind each of its scope tokens through the
+ * platform's one scoped writer (`scopedSearchTokens`).
+ */
+export declare function crmSearchFields(visibleTo: unknown, values: readonly unknown[]): {
+    searchTokens: string[];
+    scopedSearchTokens: string[];
+};
+/**
+ * The address verdict as a list asks it (AGL-3245): the state's status, or
+ * `none` when nothing is known — stored rather than left absent, because a
+ * query cannot find a field's absence and "Nothing known" is a filter.
+ */
+export declare const CRM_EMAIL_STATUS_FIELD = "emailStatus";
+export declare const CRM_EMAIL_STATUS_NONE = "none";
+export declare function crmEmailStatusKey(record: Record<string, unknown> | null | undefined): string;
+/** A lead's lead source as the list compares it: the picklist's key, `null` for none. */
+export declare const CRM_LEAD_SOURCE_KEY_FIELD = "leadSourceKey";
+export declare function crmLeadSourceKey(value: unknown): string | null;
+/** What a lead's search box reads (AGL-3246). */
+export declare const CRM_LEAD_SEARCH_SOURCES: readonly ["name", "email", "company", "jobTitle", "tags"];
+/**
+ * A lead's campaigns behind each of its `visibleTo` tokens
+ * (`host:abc~{campaignId}`), for the Leads list's Campaign filter under a
+ * site: there the scope clause is the query's one array clause, and a
+ * campaign asked of these keys answers both at once — the way the search
+ * folds into the scope through `scopedSearchTokens`.
+ */
+export declare const CRM_LEAD_SCOPED_CAMPAIGNS_FIELD = "scopedCampaignIds";
+/**
+ * Every field the Leads list queries by, from the lead as stored (or as it
+ * will be once written): the search tokens, its campaigns behind its scope,
+ * the status — `new` for a lead nobody has touched, written so `status in
+ * [new, working]` finds it — the lead source key and the address verdict.
+ */
+export declare function crmLeadListFields(record: object): {
+    searchTokens: string[];
+    scopedSearchTokens: string[];
+    scopedCampaignIds: string[];
+    status: CrmLeadStatus;
+    leadSourceKey: string | null;
+    emailStatus: string;
+};
+/** What a company's search box reads: its name and its domain. */
+export declare const CRM_COMPANY_SEARCH_SOURCES: readonly ["name", "domain"];
+export declare function crmCompanyListFields(record: object): {
+    searchTokens: string[];
+    scopedSearchTokens: string[];
+};
+/**
+ * What a deal's search box reads: its title (AGL-3315) — as word prefixes,
+ * and as `titleLower`, the whole title's key, which a reader whose access
+ * is some sites searches by its start.
+ */
+export declare function crmDealListFields(record: object): {
+    searchTokens: string[];
+    scopedSearchTokens: string[];
+    titleLower: string;
+};
+/** What a task's search box reads: its title. */
+export declare function crmTaskListFields(record: object): {
+    searchTokens: string[];
+    scopedSearchTokens: string[];
+};
+export declare const CRM_CONTACT_FACET_KEYS_FIELD = "facetKeys";
+/** The group a key names at the organization level: any holder. */
+export declare const CRM_FACET_KEY_ANY_GROUP = "*";
+/** The most facet keys one contact keeps. */
+export declare const CRM_FACET_KEYS_MAX = 600;
+/** The facet fields a contact list filters by, as their keys name them. */
+export type CrmFacetKeyField = 'owner' | 'stage' | 'source' | 'company' | 'tag' | 'orders' | 'ltv' | `custom.${string}`;
+/** A facet value as its key spells it, or `null` for a value a key cannot hold. */
+export declare function crmFacetKeyValue(value: unknown): string | null;
+/** One facet key: `{group}:{field}` for presence, `{group}:{field}={value}` for a value. */
+export declare function crmFacetKey(group: string, field: CrmFacetKeyField, value?: string): string;
+/** Every facet key a contact carries — see the block above. */
+export declare function crmContactFacetKeys(record: object): string[];
+/**
+ * What a contact's search box reads: the shared identity — the canonical
+ * name and every address — and the two profile values a person is looked
+ * up by, through their top-level search echoes (`HostContact.phone`,
+ * `HostContact.companyName`): the company's words, and the phone's digits.
+ */
+export declare const CRM_CONTACT_SEARCH_SOURCES: readonly ["name", "email", "alternateEmails", "companyName"];
+/**
+ * A phone number as the words a search box finds it by: its digits whole,
+ * without a leading country code of one to three digits, and its last seven
+ * and last four — so `5551234`, `555123` and `4567` all find +1 555 123 4567.
+ * Typed as digits: a search reads one word, and `(555)` is not one of these.
+ */
+export declare function crmPhoneSearchWords(phone: unknown): string[];
+export declare function crmContactListFields(record: object): {
+    searchTokens: string[];
+    scopedSearchTokens: string[];
+    facetKeys: string[];
+    emailStatus: string;
+};
+/**
+ * The stored fields each collection's list fields are computed from. A
+ * write that sets one of them must restamp the record — or spread
+ * {@link crmListFields} over the document it wrote.
+ */
+export declare const CRM_LIST_FIELD_INPUTS: Readonly<Record<CrmListCollection, readonly string[]>>;
+/** Every list field of one record, from the record as stored. */
+export declare function crmListFields(collection: CrmListCollection, record: object): Record<string, unknown>;
+/**
+ * The list fields a stored record carries WRONGLY — the patch that brings
+ * it level, `{}` when it already is. What a restamp and a backfill write.
+ */
+export declare function crmListFieldsPatch(collection: CrmListCollection, record: object): Record<string, unknown>;
+/**
+ * The field each collection's list ORDERS or asks `null` of, which a record
+ * must therefore carry even when it has no value: a contact, a company and a
+ * deal carry `nextTaskAtMs` ("No next activity" asks `== null`), and a task
+ * carries `dueAtMs` (every task view orders by it, and Firestore leaves a
+ * document without the ordered field out of the answer). An absent field is
+ * neither `null` nor anything else a query can ask for.
+ */
+export declare const CRM_LIST_NULLABLE_FIELD: Readonly<Record<CrmListCollection, string | null>>;
+/**
+ * The list fields a NEW record is written with: {@link crmListFields}, and
+ * the collection's {@link CRM_LIST_NULLABLE_FIELD} as `null` when the record
+ * does not set it — nothing is scheduled against a record that did not
+ * exist, and a task created undated is still one its views must reach.
+ */
+export declare function crmNewRecordListFields(collection: CrmListCollection, record: object): Record<string, unknown>;
+/** Whether a patch touches a field the collection's list fields are computed from. */
+export declare function crmListFieldsTouched(collection: CrmListCollection, patch: Record<string, unknown>): boolean;