@nitpicker/archive 0.0.0 → 0.25.1

package/lib/db-ops/resources/get-existing-resource-urls.js

@@ -0,0 +1,24 @@
+import { eachSplitted } from '../../utils/array/each-splitted.js';
+/**
+ * Return the subset of `urls` that already exist as `resource_items` rows.
+ * See `getExistingPageUrls` — same chunking strategy.
+ * @param knex - Knex query builder connected to the archive DB.
+ * @param urls - URL strings to probe.
+ * @returns URLs found among `resource_items`.
+ */
+export async function getExistingResourceUrls(knex, urls) {
+    if (urls.length === 0) {
+        return [];
+    }
+    const found = [];
+    await eachSplitted([...urls], 500, async (chunk) => {
+        const rows = await knex('resource_items')
+            .join('url_refs', 'url_refs.id', 'resource_items.url_id')
+            .select('url_refs.url as url')
+            .whereIn('url_refs.url', chunk);
+        for (const row of rows) {
+            found.push(row.url);
+        }
+    });
+    return found;
+}

package/lib/db-ops/resources/get-resource-by-url.d.ts

@@ -0,0 +1,13 @@
+import type { DB_Resource } from '../../types.js';
+import type { Knex } from 'knex';
+/**
+ * Retrieves a single sub-resource by its URL.
+ *
+ * Accepts multiple URL candidates because the stored key is the resource's
+ * `href` while callers may only know the hash-stripped form; the first match
+ * wins.
+ * @param knex - Knex query builder connected to the archive DB.
+ * @param urls - URL candidates to match against `url_refs.url`.
+ * @returns The reconstructed {@link DB_Resource} row, or `null` if none match.
+ */
+export declare function getResourceByUrl(knex: Knex, urls: readonly string[]): Promise<DB_Resource | null>;

package/lib/db-ops/resources/get-resource-by-url.js

@@ -0,0 +1,22 @@
+import { buildResourceQuery } from './build-resource-query.js';
+import { reconstructResourceRows } from './reconstruct-resource-rows.js';
+/**
+ * Retrieves a single sub-resource by its URL.
+ *
+ * Accepts multiple URL candidates because the stored key is the resource's
+ * `href` while callers may only know the hash-stripped form; the first match
+ * wins.
+ * @param knex - Knex query builder connected to the archive DB.
+ * @param urls - URL candidates to match against `url_refs.url`.
+ * @returns The reconstructed {@link DB_Resource} row, or `null` if none match.
+ */
+export async function getResourceByUrl(knex, urls) {
+    const row = await buildResourceQuery(knex)
+        .whereIn('ur.url', [...urls])
+        .first();
+    if (!row) {
+        return null;
+    }
+    const [reconstructed] = await reconstructResourceRows(knex, [row]);
+    return reconstructed ?? null;
+}

package/lib/db-ops/resources/get-resource-url-list.d.ts

@@ -0,0 +1,17 @@
+import type { Knex } from 'knex';
+/**
+ * Retrieves a flat list of all resource URLs from the `resource_items`
+ * table. URL text is normalised into `url_refs`, so the read joins the
+ * two tables and returns the resolved strings.
+ *
+ * Read in `resource_items.id`-keyset chunks rather than a single SELECT
+ * (issue #294) via `keysetPaginateById` — see that function's JSDoc for
+ * why (progress observability on a resource-heavy archive, not memory
+ * bounding).
+ * @param knex - Knex query builder connected to the archive DB.
+ * @param onProgress - Called after each chunk with the `resource_items.id`
+ *   scanned up to so far and the max id. Omit for no reporting (the
+ *   default; e.g. tests).
+ * @returns An array of resource URL strings.
+ */
+export declare function getResourceUrlList(knex: Knex, onProgress?: (scannedUpToId: number, maxId: number) => void): Promise<string[]>;

package/lib/db-ops/resources/get-resource-url-list.js

@@ -0,0 +1,26 @@
+import { keysetPaginateById } from '../_shared/keyset-paginate-by-id.js';
+/** Rows read per `resource_items.id` keyset chunk. */
+const READ_CHUNK_SIZE = 2000;
+/**
+ * Retrieves a flat list of all resource URLs from the `resource_items`
+ * table. URL text is normalised into `url_refs`, so the read joins the
+ * two tables and returns the resolved strings.
+ *
+ * Read in `resource_items.id`-keyset chunks rather than a single SELECT
+ * (issue #294) via `keysetPaginateById` — see that function's JSDoc for
+ * why (progress observability on a resource-heavy archive, not memory
+ * bounding).
+ * @param knex - Knex query builder connected to the archive DB.
+ * @param onProgress - Called after each chunk with the `resource_items.id`
+ *   scanned up to so far and the max id. Omit for no reporting (the
+ *   default; e.g. tests).
+ * @returns An array of resource URL strings.
+ */
+export async function getResourceUrlList(knex, onProgress) {
+    return keysetPaginateById(knex, 'resource_items', (lastId) => knex('resource_items')
+        .join('url_refs', 'url_refs.id', 'resource_items.url_id')
+        .where('resource_items.id', '>', lastId)
+        .orderBy('resource_items.id', 'asc')
+        .limit(READ_CHUNK_SIZE)
+        .select('resource_items.id as id', 'url_refs.url as url'), (row) => row.url, onProgress);
+}

package/lib/db-ops/resources/get-resources.d.ts

@@ -0,0 +1,8 @@
+import type { DB_Resource } from '../../types.js';
+import type { Knex } from 'knex';
+/**
+ * Retrieves all sub-resources.
+ * @param knex - Knex query builder connected to the archive DB.
+ * @returns An array of reconstructed {@link DB_Resource} rows.
+ */
+export declare function getResources(knex: Knex): Promise<DB_Resource[]>;

package/lib/db-ops/resources/get-resources.js

@@ -0,0 +1,11 @@
+import { buildResourceQuery } from './build-resource-query.js';
+import { reconstructResourceRows } from './reconstruct-resource-rows.js';
+/**
+ * Retrieves all sub-resources.
+ * @param knex - Knex query builder connected to the archive DB.
+ * @returns An array of reconstructed {@link DB_Resource} rows.
+ */
+export async function getResources(knex) {
+    const rows = await buildResourceQuery(knex);
+    return reconstructResourceRows(knex, rows);
+}

package/lib/db-ops/resources/insert-inventory-resources.d.ts

@@ -0,0 +1,24 @@
+import type { WriteRefCaches } from '../_shared/types.js';
+import type { Knex } from 'knex';
+/**
+ * Pre-insert inventory non-HTML URLs into `resource_items` as placeholder
+ * rows with `source = 'inventory-seed'` and all metadata columns NULL —
+ * the non-HTML counterpart of `insertInventorySeeds`. Used by
+ * `CrawlerOrchestrator.inventory` so the ingestion phase commits all of
+ * its non-HTML URLs in one chunked round-trip per 500 instead of N
+ * sequential `insertResource` awaits — a per-URL loop would spend
+ * minutes inside the `.bak`-protected window on a 50k-URL inventory
+ * list, where the bulk path finishes in seconds.
+ *
+ * Idempotent: both the `url_refs` and `resource_items` inserts are
+ * `ON CONFLICT ... IGNORE`, leaving existing rows untouched (the
+ * orchestrator's `getExistingResourceUrls` filter is what keeps a
+ * crawled-lineage `resource_items` row from being downgraded to the
+ * inventory label here).
+ *
+ * Chunked at 500 to stay well under SQLite's `SQLITE_MAX_VARIABLE_NUMBER`.
+ * @param knex - Knex query builder connected to the archive DB.
+ * @param caches
+ * @param urls - URL strings (already in `withoutHashAndAuth` form).
+ */
+export declare function insertInventoryResources(knex: Knex, caches: WriteRefCaches, urls: readonly string[]): Promise<void>;

package/lib/db-ops/resources/insert-inventory-resources.js

@@ -0,0 +1,64 @@
+import { resolveUrlRefs } from '../../populate-entity-tables/resolve-url-refs.js';
+import { decomposeUrl } from '../../populate-ref-tables/decompose-url.js';
+import { eachSplitted } from '../../utils/array/each-splitted.js';
+/**
+ * Pre-insert inventory non-HTML URLs into `resource_items` as placeholder
+ * rows with `source = 'inventory-seed'` and all metadata columns NULL —
+ * the non-HTML counterpart of `insertInventorySeeds`. Used by
+ * `CrawlerOrchestrator.inventory` so the ingestion phase commits all of
+ * its non-HTML URLs in one chunked round-trip per 500 instead of N
+ * sequential `insertResource` awaits — a per-URL loop would spend
+ * minutes inside the `.bak`-protected window on a 50k-URL inventory
+ * list, where the bulk path finishes in seconds.
+ *
+ * Idempotent: both the `url_refs` and `resource_items` inserts are
+ * `ON CONFLICT ... IGNORE`, leaving existing rows untouched (the
+ * orchestrator's `getExistingResourceUrls` filter is what keeps a
+ * crawled-lineage `resource_items` row from being downgraded to the
+ * inventory label here).
+ *
+ * Chunked at 500 to stay well under SQLite's `SQLITE_MAX_VARIABLE_NUMBER`.
+ * @param knex - Knex query builder connected to the archive DB.
+ * @param caches
+ * @param urls - URL strings (already in `withoutHashAndAuth` form).
+ */
+export async function insertInventoryResources(knex, caches, urls) {
+    if (urls.length === 0) {
+        return;
+    }
+    await eachSplitted([...urls], 500, async (chunk) => {
+        await knex('url_refs')
+            .insert(chunk.map((url) => ({ url, ...decomposeUrl(url) })))
+            .onConflict('url')
+            .ignore();
+        const urlIds = await resolveUrlRefs(knex, chunk);
+        const rows = chunk.map((url) => {
+            const urlId = urlIds.get(url);
+            if (urlId === undefined) {
+                throw new Error(`insertInventoryResources: url_refs.id not resolved for ${url}`);
+            }
+            caches.urlIds.set(url, urlId);
+            return {
+                url_id: urlId,
+                is_external: 0,
+                status: null,
+                status_text: null,
+                content_type_id: null,
+                content_length: null,
+                header_set_id: null,
+                compress: 0,
+                cdn: 0,
+                source: 'inventory-seed',
+            };
+        });
+        await knex('resource_items').insert(rows).onConflict('url_id').ignore();
+        const inserted = (await knex
+            .select('ri.id', 'ur.url')
+            .from('resource_items as ri')
+            .join('url_refs as ur', 'ur.id', 'ri.url_id')
+            .whereIn('ur.url', chunk));
+        for (const row of inserted) {
+            caches.resourceIds.set(row.url, row.id);
+        }
+    });
+}

package/lib/db-ops/resources/insert-resource-referrers.d.ts

@@ -0,0 +1,15 @@
+import type { WriteRefCaches } from '../_shared/types.js';
+import type { Knex } from 'knex';
+/**
+ * Inserts a referrer relationship between a resource and a page into the
+ * `resource_ref_edges` table. Silently skips if the resource is not found.
+ *
+ * A repeat observation of the same `(resource, page)` pair is ignored
+ * (`ON CONFLICT ... IGNORE`), leaving `count` at its DEFAULT `1` — one
+ * row per pair, matching the legacy uniqueness contract.
+ * @param knex - Knex query builder connected to the archive DB.
+ * @param caches - The connection's write-side id caches.
+ * @param src - The URL of the resource.
+ * @param pageUrl - The URL of the page that references the resource.
+ */
+export declare function insertResourceReferrers(knex: Knex, caches: WriteRefCaches, src: string, pageUrl: string): Promise<void>;

package/lib/db-ops/resources/insert-resource-referrers.js

@@ -0,0 +1,54 @@
+import { resolveContentItemId } from '../_shared/resolve-content-item-id.js';
+/**
+ * Inserts a referrer relationship between a resource and a page into the
+ * `resource_ref_edges` table. Silently skips if the resource is not found.
+ *
+ * A repeat observation of the same `(resource, page)` pair is ignored
+ * (`ON CONFLICT ... IGNORE`), leaving `count` at its DEFAULT `1` — one
+ * row per pair, matching the legacy uniqueness contract.
+ * @param knex - Knex query builder connected to the archive DB.
+ * @param caches - The connection's write-side id caches.
+ * @param src - The URL of the resource.
+ * @param pageUrl - The URL of the page that references the resource.
+ */
+export async function insertResourceReferrers(knex, caches, src, pageUrl) {
+    const resourceId = await findResourceIdByUrl(knex, caches, src);
+    if (resourceId === undefined) {
+        // Ignore when the resource is not found
+        return;
+    }
+    const pageId = await resolveContentItemId(knex, caches, pageUrl);
+    await knex('resource_ref_edges')
+        .insert({
+        resource_id: resourceId,
+        page_id: pageId,
+    })
+        .onConflict(['resource_id', 'page_id'])
+        .ignore();
+}
+/**
+ * Cache-first lookup of `resource_items.id` by the resource URL. The
+ * cache only ever gains entries for URLs that exist in the table
+ * (resource identities are never deleted during a crawl), so a hit is
+ * always valid; a miss falls through to a `url_refs` join.
+ * @param knex - Knex query builder.
+ * @param caches - The connection's write-side id caches.
+ * @param url - The resource URL, verbatim as stored.
+ * @returns The resource id, or `undefined` when the URL is unknown.
+ */
+async function findResourceIdByUrl(knex, caches, url) {
+    const cached = caches.resourceIds.get(url);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const [row] = (await knex
+        .select('ri.id')
+        .from('resource_items as ri')
+        .join('url_refs as ur', 'ur.id', 'ri.url_id')
+        .where('ur.url', url));
+    if (row === undefined) {
+        return undefined;
+    }
+    caches.resourceIds.set(url, row.id);
+    return row.id;
+}

package/lib/db-ops/resources/insert-resource.d.ts

@@ -0,0 +1,34 @@
+import type { PageSource } from '../../types.js';
+import type { Resource } from '../../utils/types/types.js';
+import type { WriteRefCaches } from '../_shared/types.js';
+import type { Knex } from 'knex';
+/**
+ * Inserts a sub-resource into the `resource_items` table, interning its
+ * URL / content type / response headers into the ref tables first. A
+ * resource's identity URL routes through {@link resolveUrlOrBlob} like an
+ * image `src` — a large inline `data:` URI (e.g. a CSS
+ * `background-image` sub-resource) lands in `blob_refs` instead of
+ * `url_refs`.
+ *
+ * A conflict on the identity column (`url_id` or `url_blob_id`) is an
+ * **upgrade-only merge**, not first-write-wins: the existing row's
+ * response fields (`status` / `status_text` / `content_type_id` /
+ * `content_length` / `header_set_id` / `compress` / `cdn`) are replaced
+ * only when the existing row currently has `status IS NULL` (beholder's
+ * signal for "the request never got a response" — see the `Resource`
+ * type) AND the new observation has a non-null `status`. A resource that
+ * failed on first sight and later succeeds (the exact case
+ * `--retry-failed` re-renders a page for) is therefore healed instead of
+ * staying frozen at its failure; a resource that already has a real
+ * response never gets overwritten by a later transient failure, and two
+ * failures in a row are a no-op — neither carries new information.
+ *
+ * The `source` provenance label is written ONLY on insert; a conflict
+ * (upgrade or no-op alike) leaves an existing row's source untouched
+ * (this is what makes a second `crawl --inventory` non-destructive).
+ * @param knex - Knex query builder connected to the archive DB.
+ * @param caches - The connection's write-side id caches.
+ * @param resource - The resource data to insert.
+ * @param source - Provenance label for new rows. `undefined` leaves the DB DEFAULT (`'crawled'`).
+ */
+export declare function insertResource(knex: Knex, caches: WriteRefCaches, resource: Resource, source?: PageSource): Promise<void>;

package/lib/db-ops/resources/insert-resource.js

@@ -0,0 +1,73 @@
+import { normalizeContentType } from '../../content-type/normalize-content-type.js';
+import { resolveUrlOrBlob } from '../_shared/resolve-url-or-blob.js';
+import { upsertContentTypeRef } from '../_shared/upsert-content-type-ref.js';
+import { upsertResponseHeaders } from '../_shared/upsert-response-headers.js';
+/**
+ * Inserts a sub-resource into the `resource_items` table, interning its
+ * URL / content type / response headers into the ref tables first. A
+ * resource's identity URL routes through {@link resolveUrlOrBlob} like an
+ * image `src` — a large inline `data:` URI (e.g. a CSS
+ * `background-image` sub-resource) lands in `blob_refs` instead of
+ * `url_refs`.
+ *
+ * A conflict on the identity column (`url_id` or `url_blob_id`) is an
+ * **upgrade-only merge**, not first-write-wins: the existing row's
+ * response fields (`status` / `status_text` / `content_type_id` /
+ * `content_length` / `header_set_id` / `compress` / `cdn`) are replaced
+ * only when the existing row currently has `status IS NULL` (beholder's
+ * signal for "the request never got a response" — see the `Resource`
+ * type) AND the new observation has a non-null `status`. A resource that
+ * failed on first sight and later succeeds (the exact case
+ * `--retry-failed` re-renders a page for) is therefore healed instead of
+ * staying frozen at its failure; a resource that already has a real
+ * response never gets overwritten by a later transient failure, and two
+ * failures in a row are a no-op — neither carries new information.
+ *
+ * The `source` provenance label is written ONLY on insert; a conflict
+ * (upgrade or no-op alike) leaves an existing row's source untouched
+ * (this is what makes a second `crawl --inventory` non-destructive).
+ * @param knex - Knex query builder connected to the archive DB.
+ * @param caches - The connection's write-side id caches.
+ * @param resource - The resource data to insert.
+ * @param source - Provenance label for new rows. `undefined` leaves the DB DEFAULT (`'crawled'`).
+ */
+export async function insertResource(knex, caches, resource, source) {
+    const slot = await resolveUrlOrBlob(knex, caches, resource.url.href);
+    // Canonicalize like the page path (see `insertPage`) so resource
+    // content-type filters / dedupe keys are case- and whitespace-stable.
+    const contentType = normalizeContentType(resource.contentType);
+    const contentTypeId = contentType == null || contentType === ''
+        ? null
+        : await upsertContentTypeRef(knex, caches, contentType);
+    const headerSetId = await upsertResponseHeaders(knex, caches, resource.headers);
+    const identityColumn = slot.blob === null ? 'url_id' : 'url_blob_id';
+    const identityValue = slot.blob === null ? slot.url : slot.blob;
+    const responseFields = {
+        is_external: resource.isExternal ? 1 : 0,
+        status: resource.status,
+        status_text: resource.statusText,
+        content_type_id: contentTypeId,
+        content_length: resource.contentLength,
+        header_set_id: headerSetId,
+        compress: resource.compress || 0,
+        cdn: resource.cdn || 0,
+    };
+    const existing = await knex('resource_items')
+        .select('id', 'status')
+        .where(identityColumn, identityValue)
+        .first();
+    if (existing === undefined) {
+        await knex('resource_items').insert({
+            url_id: slot.url,
+            url_blob_id: slot.blob,
+            ...responseFields,
+            ...(source === undefined ? {} : { source }),
+        });
+        return;
+    }
+    if (existing.status === null && resource.status !== null) {
+        await knex('resource_items')
+            .where('id', existing.id)
+            .update(responseFields);
+    }
+}

package/lib/db-ops/resources/reconstruct-resource-rows.d.ts

@@ -0,0 +1,26 @@
+import type { DB_Resource } from '../../types.js';
+import type { Knex } from 'knex';
+/**
+ * Raw row shape produced by {@link ../resources/build-resource-query.js}
+ * before `responseHeaders` reconstruction.
+ */
+interface RawResourceRow extends Omit<DB_Resource, 'responseHeaders'> {
+    /** `resource_items.header_set_id`, or null when no headers were recorded. */
+    headerSetId: number | null;
+}
+/**
+ * Reconstructs `responseHeaders` (JSON string) for a batch of raw resource
+ * rows. Headers load through
+ * {@link ../_shared/load-response-headers-by-set-ids.js} (chunked batch
+ * lookup, never N+1) — the same reconstruction the page read path uses,
+ * so pages and resources always agree on how a given `header_set_id`
+ * reads back.
+ * @param knex - Knex query builder connected to the archive DB.
+ * @param rows - Raw rows from {@link ../resources/build-resource-query.js}.
+ * @returns Fully reconstructed `DB_Resource` rows, in the same order as `rows`.
+ * @example
+ * const raw = await buildResourceQuery(knex).whereIn('ur.url', urls);
+ * const resources = await reconstructResourceRows(knex, raw);
+ */
+export declare function reconstructResourceRows(knex: Knex, rows: readonly RawResourceRow[]): Promise<DB_Resource[]>;
+export {};

package/lib/db-ops/resources/reconstruct-resource-rows.js

@@ -0,0 +1,30 @@
+import { loadResponseHeadersBySetIds } from '../_shared/load-response-headers-by-set-ids.js';
+/**
+ * Reconstructs `responseHeaders` (JSON string) for a batch of raw resource
+ * rows. Headers load through
+ * {@link ../_shared/load-response-headers-by-set-ids.js} (chunked batch
+ * lookup, never N+1) — the same reconstruction the page read path uses,
+ * so pages and resources always agree on how a given `header_set_id`
+ * reads back.
+ * @param knex - Knex query builder connected to the archive DB.
+ * @param rows - Raw rows from {@link ../resources/build-resource-query.js}.
+ * @returns Fully reconstructed `DB_Resource` rows, in the same order as `rows`.
+ * @example
+ * const raw = await buildResourceQuery(knex).whereIn('ur.url', urls);
+ * const resources = await reconstructResourceRows(knex, raw);
+ */
+export async function reconstructResourceRows(knex, rows) {
+    const headerSetIds = [
+        ...new Set(rows.map((r) => r.headerSetId).filter((id) => id != null)),
+    ];
+    const headersBySetId = await loadResponseHeadersBySetIds(knex, headerSetIds);
+    return rows.map((row) => {
+        const { headerSetId, ...rest } = row;
+        return {
+            ...rest,
+            responseHeaders: headerSetId == null
+                ? null
+                : JSON.stringify(headersBySetId.get(headerSetId) ?? {}),
+        };
+    });
+}

package/lib/db-ops/templates/assign-template-labels.d.ts

@@ -0,0 +1,60 @@
+import type { AssignTemplateLabelsParams, TemplateLabel } from './types.js';
+/**
+ * Assigns every cluster of a fresh template classification its
+ * {@link TemplateLabel}, carrying labels forward from the previous
+ * classification wherever the same template survived the re-run.
+ *
+ * ## Inheritance
+ *
+ * A new cluster inherits an old cluster's label when the two share a
+ * **mutual majority** of pages: the overlap is more than half of the new
+ * cluster *and* more than half of the old one. Mutual majority means at
+ * most one new cluster can claim a given old label, and a cluster that
+ * merely absorbed a few pages of a much larger old template does not steal
+ * its name. A split keeps the old label on the half that holds most of the
+ * old pages; the other half is named afresh.
+ *
+ * The old cluster's size counts only pages that are classified in the new
+ * run too. Pages the crawl has since dropped (`--recrawl` turned them into
+ * redirects, errors, …) are not evidence that the template changed, so
+ * they must not dilute the old half of the majority — otherwise an old
+ * 7-page cluster whose 4 missing pages left 3 unchanged ones would fail
+ * `3 > 7/2` and be renamed for no reason.
+ *
+ * Page ids are the identity used for overlap (not URLs) because they are
+ * what `page_templates` stores and they survive `--append` / `--recrawl`
+ * without renumbering.
+ *
+ * ## Fresh labels
+ *
+ * Clusters left without an inherited label are numbered in page-count
+ * order (largest first, template key as a tie-break) so a first run reads
+ * naturally: `A` is the section's biggest template. Each takes the next
+ * ordinal **after every ordinal in `previousLabels` for its section**, so a
+ * letter is never re-issued to a different template — which would silently
+ * change what "events template B" means between two people's archives.
+ * That guarantee is only as good as `previousLabels`: `replacePageTemplates`
+ * keeps the rows of clusters that disappeared (retired labels) precisely so
+ * they stay in this set across any number of later runs.
+ *
+ * ## Section
+ *
+ * A cluster's section is the first path segment every member URL shares
+ * (`events` for `/events/...`). Members spread over several segments, or
+ * all at the site root, yield `null`: such a cluster is numbered in the
+ * site-wide sequence. An inherited label keeps its old section even if the
+ * cluster's members have since drifted — stability of the name wins over
+ * keeping the section literally accurate.
+ * @param params - See {@link AssignTemplateLabelsParams}.
+ * @returns Template key → label, one entry per cluster in `params.clusters`.
+ * @example
+ * ```ts
+ * const labels = assignTemplateLabels({
+ *   clusters: new Map([['["path:events","cluster:0"]', { pageIds: [1, 2], urls: ['https://example.com/events/a', 'https://example.com/events/b'] }]]),
+ *   previousMembership: new Map(),
+ *   previousLabels: new Map(),
+ * });
+ * labels.get('["path:events","cluster:0"]'); // { section: 'events', ordinal: 1 }
+ * ```
+ */
+export declare function assignTemplateLabels(params: AssignTemplateLabelsParams): Map<string, TemplateLabel>;