@rebasepro/server 0.25.1 → 0.26.0

package/dist/storage/GCSStorageController.d.ts

@@ -24,6 +24,8 @@ export declare class GCSStorageController implements StorageController {
      * @see S3StorageController.knownBuckets
      */
     knownBuckets(): string[];
+    /** See {@link StorageController.storageLocation}: bucket names are global. */
+    storageLocation(): string;
     putObject({ file, key, metadata, bucket }: UploadFileProps, options?: PutObjectOptions): Promise<UploadFileResult>;
     /**
      * Read the object's metadata and nothing else — no signing.

package/dist/storage/LocalStorageController.d.ts

@@ -67,6 +67,11 @@ export declare class LocalStorageController implements StorageController {
      * not have been written to yet.
      */
     knownBuckets(): string[];
+    /**
+     * See {@link StorageController.storageLocation}: the default bucket's
+     * directory, with the storage root's links resolved.
+     */
+    storageLocation(): string;
     /**
      * Ensure directory exists, creating it if necessary
      */
@@ -128,11 +133,11 @@ export declare class LocalStorageController implements StorageController {
     /**
      * A folder's entries for a listing page.
      *
-     * A page token is an index into these entries, and every continuation
-     * page used to read the whole folder again to find its place: a folder of
+     * A page token names the last of these entries a page read, and every
+     * continuation page used to read the whole folder again to find its place: a folder of
      * n entries listed in pages of p cost n/p full reads. A first page reads
      * the folder and, when there is a next page, keeps the read; a
-     * continuation page indexes into it while all of these hold:
+     * continuation page finds its place in it while all of these hold:
      *
      *  - the folder's mtime is the one read with it. Adding, removing or
      *    renaming an entry changes it, which is the invalidation;

package/dist/storage/S3StorageController.d.ts

@@ -24,6 +24,8 @@ export declare class S3StorageController implements StorageController {
      * can reach — and a mistyped one came back as "file not found".
      */
     knownBuckets(): string[];
+    /** See {@link StorageController.storageLocation}: the endpoint (AWS when none) and the bucket. */
+    storageLocation(): string;
     /** See {@link StorageController.maxFileSize}. */
     maxFileSize(): number;
     /**

package/dist/storage/maintenance-keys.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Where storage maintenance keeps its own records inside a source: the state
+ * and result of an orphan scan (`rebase storage orphans`), which a worker
+ * writes and any server process reads back.
+ *
+ * Reserved at the route layer like the rendition space, in both directions. A
+ * scan's result is the list a later delete acts on, so a caller who could
+ * write one could name files for an administrator's delete to remove; and it
+ * lists keys a caller may not be allowed to see.
+ */
+export declare const MAINTENANCE_PREFIX = "_rebase/maintenance/";
+/**
+ * True for a key in the reserved maintenance space — the prefix itself, or
+ * anything under it. Folded the way the filesystem under a local bucket folds
+ * it, as {@link isRenditionKey} is.
+ */
+export declare function isMaintenanceKey(key: string): boolean;

package/dist/storage/maintenance-routes.d.ts

@@ -1,23 +1,46 @@
 /**
  * `/admin/storage` — the routes behind `rebase storage orphans` and
  * `rebase storage move`. Admin-only; the caller mounts them behind the admin
- * gate (`database:read` to read, `database:write` to delete or move).
+ * gate (`database:read` to read, `database:write` for every other method).
  *
- *   GET    /orphans?storageId=&olderThanHours=   objects no row names
- *   DELETE /orphans?storageId=&olderThanHours=   delete them, found again first
+ *   POST   /orphans/scans?storageId=&olderThanHours=   start a scan, in the background
+ *   GET    /orphans/scans/:id?storageId=               its progress, then its report
+ *   DELETE /orphans?scan=:id&storageId=                delete a completed scan's orphans, in the background
+ *   GET    /orphans?storageId=&olderThanHours=         deprecated: a scan inside the request
+ *   DELETE /orphans?storageId=&olderThanHours=         deprecated: scan and delete inside the request
  *   POST   /move  { from, to, prefix?, cursor?, limit?, deleteSource? }
+ *   POST   /move/verify  (the same body)            what a move left behind
  */
 import { Hono } from "hono";
-import type { CollectionConfig, DataDriver } from "@rebasepro/types";
+import type { CollectionCallbacks, CollectionConfig, DataDriver } from "@rebasepro/types";
 import type { HonoEnv } from "../api/types.js";
+import type { JobQueueClient } from "../jobs/types.js";
 import type { StorageController } from "./types.js";
 import type { StorageRegistry } from "./storage-registry.js";
+import { type OrphanScanService } from "./orphan-scans.js";
 export interface StorageMaintenanceRoutesConfig {
     registry?: StorageRegistry;
     controller?: StorageController;
     /** The collections whose rows are read for references, read per request. */
     collections: () => readonly CollectionConfig[];
-    /** The unscoped driver serving a collection: every row, whoever wrote it. */
+    /**
+     * The unscoped driver serving a collection: every row, whoever wrote it.
+     * Its `scanStoredRows` is read when it has one — rows as stored, past
+     * every read hook.
+     */
     driverFor: (collection: CollectionConfig) => DataDriver | undefined;
+    /** The global callbacks, read per request: a global read hook makes every collection hooked. */
+    globalCallbacks?: () => CollectionCallbacks | undefined;
+    /** Row history, when kept: a file only an entry names is restored by a revert. */
+    history?: {
+        scanStoredValues?(pageSize?: number): AsyncIterable<unknown[]>;
+    };
+    /** The durable job queue a scan runs on, read per scan. Absent: scans run in this process. */
+    jobs?: () => JobQueueClient | undefined;
+    /**
+     * The scan service, when the backend shares one with the job queue's
+     * `storage.orphans` handler. Built from the fields above when left out.
+     */
+    orphanScans?: OrphanScanService;
 }
 export declare function createStorageMaintenanceRoutes(config: StorageMaintenanceRoutesConfig): Hono<HonoEnv>;

package/dist/storage/maintenance.d.ts

@@ -11,7 +11,7 @@
  * whichever property holds it. A file is reported only when nothing points at
  * it at all.
  */
-import type { CollectionConfig, DataDriver } from "@rebasepro/types";
+import type { CollectionCallbacks, CollectionConfig, DataDriver } from "@rebasepro/types";
 import type { StorageController } from "./types.js";
 /** One stored object, as a listing describes it. */
 export interface StoredObjectEntry {
@@ -51,6 +51,12 @@ export interface UnscannedCollection {
     collection: string;
     reason: string;
 }
+/**
+ * Whether reading a collection through `fetchCollection` could hide a row or
+ * change a value: a `beforeQuery` or an `afterRead`, the collection's own, a
+ * global one, or a property's.
+ */
+export declare function hasReadHooks(collection: CollectionConfig, globalCallbacks?: CollectionCallbacks): boolean;
 /**
  * Remove from `keys` every key some row names.
  *
@@ -59,13 +65,28 @@ export interface UnscannedCollection {
  * serves the collection. What is left in `keys` afterwards is named by no row.
  * A collection that could not be read is returned, and its rows count for
  * nothing: a caller must not treat what is left as unused when any is.
+ *
+ * Rows are read as stored, through the driver's `scanStoredRows`. A driver
+ * without it is read through `fetchCollection` only for a collection with no
+ * read hooks: a `beforeQuery` scoping rows to `context.user` — there is none
+ * here — or an `afterRead` rewriting a file field would hide a reference, and
+ * the file it names would be deleted as unused. Such a collection is
+ * returned as unscanned instead.
  */
 export declare function removeReferencedKeys(keys: Set<string>, collections: readonly CollectionConfig[], driverFor: (collection: CollectionConfig) => DataDriver | undefined, options?: {
     pageSize?: number;
+    globalCallbacks?: CollectionCallbacks;
+    /** Counted into as it goes, and `onProgress` called after each page. */
+    progress?: ScanProgress;
+    onProgress?: () => void;
+    /** Checked between pages: an aborted scan stops, and throws. */
+    signal?: AbortSignal;
 }): Promise<{
     scanned: string[];
     unscanned: UnscannedCollection[];
 }>;
+/** How row history is named among the scanned and unscanned collections. */
+export declare const HISTORY_SCAN_NAME = "(row history)";
 /** What `findOrphans` found. */
 export interface OrphanReport {
     /** Objects in the source, internal ones aside. */
@@ -80,6 +101,42 @@ export interface OrphanReport {
     scanned: string[];
     unscanned: UnscannedCollection[];
 }
+/** Row history, as a scan reads it. */
+export interface StoredHistory {
+    scanStoredValues?(pageSize?: number): AsyncIterable<unknown[]>;
+}
+/** Where references to stored files are read from: every row, and history. */
+export interface ReferenceSources {
+    collections: readonly CollectionConfig[];
+    driverFor: (collection: CollectionConfig) => DataDriver | undefined;
+    /** The callbacks every collection runs, which may scope or rewrite its reads. */
+    globalCallbacks?: CollectionCallbacks;
+    /**
+     * Row history, when the backend keeps it: a revert restores the values an
+     * entry holds, so a file only history names is still in use. One that
+     * cannot be read is reported unscanned, as {@link HISTORY_SCAN_NAME}.
+     */
+    history?: StoredHistory;
+}
+/** How far a scan has got. Counted into in place, so a caller can report it while it runs. */
+export interface ScanProgress {
+    phase: "listing" | "rows" | "history" | "deleting" | "done";
+    /** Objects listed in the source so far. */
+    filesScanned: number;
+    /** Rows read so far, over every collection. */
+    rowsScanned: number;
+    /** History entries read so far. */
+    historyEntriesScanned: number;
+    /** Collections finished, read or not. */
+    collectionsScanned: number;
+    collectionsTotal: number;
+    /** The collection being read now. */
+    currentCollection?: string;
+    /** The collections that could not be read, as they are found. */
+    unscanned: UnscannedCollection[];
+}
+/** A progress record at the start of a scan. */
+export declare function emptyScanProgress(): ScanProgress;
 /**
  * The objects of one source that no row names.
  *
@@ -87,13 +144,52 @@ export interface OrphanReport {
  *        an orphan: the admin panel uploads a file before the row that names it
  *        is saved. One whose age the listing does not say is not either.
  */
-export declare function findOrphans(options: {
+export declare function findOrphans(options: ReferenceSources & {
     controller: StorageController;
-    collections: readonly CollectionConfig[];
-    driverFor: (collection: CollectionConfig) => DataDriver | undefined;
     olderThanMs: number;
     now?: number;
+    /** Counted into as the scan goes; `onProgress` is called after each page. */
+    progress?: ScanProgress;
+    onProgress?: () => void;
+    /** Checked between pages: an aborted scan stops, and throws. */
+    signal?: AbortSignal;
 }): Promise<OrphanReport>;
+/** What deleting a scan's orphans did. */
+export interface OrphanDeletion {
+    deleted: string[];
+    /** Candidates not deleted, because something changed since the scan. */
+    kept: {
+        key: string;
+        reason: string;
+    }[];
+    failed: {
+        key: string;
+        error: string;
+    }[];
+    /** Collections the re-check could not read; when any is, nothing was deleted. */
+    unscanned: UnscannedCollection[];
+}
+/**
+ * Delete the orphans an earlier scan found — each only if it is still one.
+ *
+ * Every row and history entry is read again, against the candidates alone
+ * (the source is not listed again): a row written since the scan may name one
+ * now. When a collection cannot be read, nothing is deleted. Then, right
+ * before each delete, the object is asked for again: one that is gone, was
+ * written again since the scan (another size or time), or is now inside the
+ * grace period is kept.
+ */
+export declare function deleteScannedOrphans(options: ReferenceSources & {
+    controller: StorageController;
+    candidates: readonly StoredObjectEntry[];
+    olderThanMs: number;
+    now?: () => number;
+    progress?: ScanProgress;
+    onProgress?: () => void;
+    /** Called after each file deleted. */
+    onDeleted?: (key: string) => void;
+    signal?: AbortSignal;
+}): Promise<OrphanDeletion>;
 /** What happened to one object in a move. */
 export interface MovedObject {
     key: string;
@@ -124,3 +220,39 @@ export declare function moveObjects(options: {
     moved: MovedObject[];
     cursor?: string;
 }>;
+/** A file a move did not move, and why it counts as not moved. */
+export interface NotMovedObject {
+    key: string;
+    reason: string;
+}
+/**
+ * List the source again after a move and name every file it did not move,
+ * `limit` source objects per call; hand the returned `cursor` back for the
+ * next ones.
+ *
+ * Defence in depth: a move reports what its own walk saw, and a walk that
+ * skipped files (as the local listing's page token once did, over a folder
+ * the move was emptying) reported success over the half it moved. A fresh
+ * listing does not share the walk's state. With `deleteSource`, every file
+ * still in the source is not moved; without it, a file the target holds no
+ * copy of the same size of.
+ */
+export declare function verifyMove(options: {
+    from: StorageController;
+    to: StorageController;
+    prefix?: string;
+    cursor?: string;
+    limit?: number;
+    deleteSource?: boolean;
+}): Promise<{
+    checked: number;
+    notMoved: NotMovedObject[];
+    cursor?: string;
+}>;
+/**
+ * Whether two sources store in the same place — one bucket or directory under
+ * two names. Asked by their `storageLocation` when both can say; otherwise by
+ * a probe object written to `a` under the internal folder, looked for in `b`,
+ * and deleted.
+ */
+export declare function storesInSamePlace(a: StorageController, b: StorageController): Promise<boolean>;

package/dist/storage/orphan-scans.d.ts

@@ -0,0 +1,120 @@
+import type { CollectionCallbacks, CollectionConfig, DataDriver } from "@rebasepro/types";
+import type { JobQueueClient } from "../jobs/types.js";
+import type { StorageController } from "./types.js";
+import type { StorageRegistry } from "./storage-registry.js";
+import { type OrphanReport, type ScanProgress, type StoredHistory } from "./maintenance.js";
+/** The job task a scan, or a scan's delete, runs as. Frozen: workers of another release claim it by name. */
+export declare const STORAGE_ORPHANS_TASK = "storage.orphans";
+/** Where scan records are kept inside the scanned source. */
+export declare const ORPHAN_SCAN_FOLDER = "_rebase/maintenance/orphan-scans";
+/**
+ * How long after it completed a scan's result may still be deleted from.
+ * Every candidate is checked again before it goes, so this is not what keeps
+ * a file in use; it keeps a delete acting on what the person just read.
+ */
+export declare const ORPHAN_SCAN_TTL_MS: number;
+/**
+ * A scan, or a delete, that has written no progress for this long is reported
+ * failed: the process running it stopped — a deploy, a crash — and nothing
+ * else will finish it. Progress is written at least once a page.
+ */
+export declare const ORPHAN_SCAN_STALL_MS: number;
+/** The default grace period: an upload whose row is not saved yet is a day old at most. */
+export declare const DEFAULT_OLDER_THAN_HOURS = 24;
+/** Who runs a scan: the job queue's workers, or the server process that was asked. */
+export type OrphanScanRunner = "worker" | "in-process";
+export type OrphanScanStatus = "queued" | "running" | "completed" | "failed";
+/** A delete from a completed scan, as its record holds it. */
+export interface OrphanScanDeletion {
+    status: OrphanScanStatus;
+    runner: OrphanScanRunner;
+    jobId?: string;
+    requestedAt: string;
+    startedAt?: string;
+    updatedAt: string;
+    completedAt?: string;
+    progress: ScanProgress & {
+        candidates: number;
+        deleted: number;
+    };
+    result?: {
+        deleted: string[];
+        kept: {
+            key: string;
+            reason: string;
+        }[];
+        failed: {
+            key: string;
+            error: string;
+        }[];
+    };
+    error?: string;
+    /** Set on the way out when a running delete has stopped reporting. */
+    note?: string;
+}
+/** A scan's record: what `GET /orphans/scans/:id` answers. */
+export interface OrphanScanState {
+    id: string;
+    storageId: string;
+    olderThanHours: number;
+    runner: OrphanScanRunner;
+    jobId?: string;
+    status: OrphanScanStatus;
+    createdAt: string;
+    startedAt?: string;
+    updatedAt: string;
+    completedAt?: string;
+    progress: ScanProgress;
+    /** The report, once completed: what the synchronous `GET /orphans` answered. */
+    result?: OrphanReport;
+    error?: string;
+    /** Said on the way out, never stored: why a queued scan may not have started, or that one stalled. */
+    note?: string;
+    deletion?: OrphanScanDeletion;
+}
+/** A `storage.orphans` job's payload. */
+export interface OrphanScanTaskPayload {
+    scanId: string;
+    storageId: string;
+    mode: "scan" | "delete";
+}
+export interface OrphanScanServiceConfig {
+    registry?: StorageRegistry;
+    controller?: StorageController;
+    /** The collections whose rows are read for references, read when a scan runs. */
+    collections: () => readonly CollectionConfig[];
+    /** The unscoped driver serving a collection. See `StorageMaintenanceRoutesConfig.driverFor`. */
+    driverFor: (collection: CollectionConfig) => DataDriver | undefined;
+    globalCallbacks?: () => CollectionCallbacks | undefined;
+    history?: StoredHistory;
+    /**
+     * The durable job queue, read when a scan starts: present, the scan is a
+     * `storage.orphans` job its workers run; absent, it runs in this process.
+     */
+    jobs?: () => JobQueueClient | undefined;
+    /** For tests. */
+    now?: () => number;
+}
+export interface OrphanScanService {
+    /** Record a scan and set it going. Resolves with its record, `queued`. */
+    start(options: {
+        storageId?: string;
+        olderThanHours?: number;
+    }): Promise<OrphanScanState>;
+    /** A scan's record, or `undefined` when this source holds none by that id. */
+    status(storageId: string | undefined, id: string): Promise<OrphanScanState | undefined>;
+    /** Start deleting a completed scan's orphans. Throws the refusal when it may not. */
+    requestDeletion(storageId: string | undefined, id: string): Promise<OrphanScanState>;
+    /** Run a `storage.orphans` job: the scan, or its delete. */
+    runTask(payload: OrphanScanTaskPayload, signal?: AbortSignal): Promise<void>;
+}
+/**
+ * The storage source a request names, or the 404 that lists the ones served.
+ */
+export declare function resolveStorageSource(sources: {
+    registry?: StorageRegistry;
+    controller?: StorageController;
+}, rawId: unknown, label: string): StorageController;
+/** `olderThanHours` as a request sends it, checked. */
+export declare function parseOlderThanHours(raw: string | number | undefined): number;
+export declare function createOrphanScanService(config: OrphanScanServiceConfig): OrphanScanService;

package/dist/storage/types.d.ts

@@ -210,6 +210,17 @@ export interface StorageController {
      * when the caller names none, and each provider maps it to its own.
      */
     knownBuckets?(): string[];
+    /**
+     * Where this controller's default bucket physically is, as a string two
+     * controllers return alike exactly when they store in the same place: a
+     * resolved directory, an endpoint and bucket.
+     *
+     * Two sources declared over one bucket or directory are one store under
+     * two names, and `rebase storage move --delete-source` between them found
+     * every object "already there" — it is the same object — and deleted it
+     * from both. A controller without this is found out by a probe object.
+     */
+    storageLocation?(): string;
     /**
      * The largest file this controller accepts, in bytes.
      *

package/dist/strings.es-B7QLnHh2.js

@@ -0,0 +1,96 @@
+import { createRequire as __rebaseCreateRequire } from "module";
+import __rebaseProcess from "process";
+globalThis.process ??= __rebaseProcess;
+__rebaseCreateRequire(import.meta.url);
+var snakeCaseRegex = /[A-Z]{2,}(?=[A-Z][a-z]|\b)|[A-Z]?[a-z]+|[0-9]+(?:[a-z](?![a-z]))?|[A-Z]/g;
+var toSnakeCase = (str) => {
+	if (!str || typeof str !== "string") return "";
+	const regExpMatchArray = str.match(snakeCaseRegex);
+	if (!regExpMatchArray) return "";
+	return regExpMatchArray.map((x) => x.toLowerCase()).join("_");
+};
+/**
+* Are these two identifiers one edit apart, ignoring case?
+*
+* Tight on purpose. A suggester that fires on two edits offers `columnWidth`
+* for `colWith` and `readOnly` for `required`, and a "did you mean" that is
+* usually wrong teaches people to stop reading them. One edit covers what
+* actually happens — a dropped letter (`multilne`), a doubled one, a transposed
+* pair (`validaton`), a wrong case — and nothing else.
+*
+* Lives here rather than beside either caller because both the CLI's manifest
+* reader and the server's collection validator answer the same question about
+* an unknown key, and two copies of a similarity rule is two rules the moment
+* one of them is tuned.
+*/
+function isNearMiss(a, b) {
+	const x = a.toLowerCase();
+	const y = b.toLowerCase();
+	if (x === y) return true;
+	if (Math.abs(x.length - y.length) > 1) return false;
+	const [shorter, longer] = x.length <= y.length ? [x, y] : [y, x];
+	let i = 0;
+	let j = 0;
+	let edits = 0;
+	while (i < shorter.length && j < longer.length) {
+		if (shorter[i] === longer[j]) {
+			i++;
+			j++;
+			continue;
+		}
+		if (++edits > 1) return false;
+		if (shorter.length === longer.length) i++;
+		j++;
+	}
+	return edits + (longer.length - j) + (shorter.length - i) <= 1;
+}
+/**
+* The key in `known` that `key` was probably meant to be, if any.
+*
+* `undefined` when nothing is close — which is the common case for a key that
+* is simply from a newer version, and the reason the caller must be able to say
+* "unknown" without saying "wrong".
+*/
+function suggestNearMiss(known, key) {
+	return known.find((candidate) => isNearMiss(candidate, key));
+}
+/**
+* The terms a user meant when they typed into a search box.
+*
+* A search box is not a substring box. Typing `sebastian melendez` on a
+* collection whose name is split across `first_name` and `last_name` has to
+* find the row, and matching the whole string against each field separately
+* cannot: no single column holds both words. Splitting on whitespace and
+* requiring *every* term to match *some* field is what does, and it is what
+* `websearch_to_tsquery` already does for collections that declared a `search`
+* block — so this is also what keeps the two search paths answering the same
+* question.
+*
+* It fixes the trailing space too: `sebastian ` matched nothing at all, because
+* the space was part of the pattern.
+*
+* A double-quoted run is one term, again matching the full-text path, so a
+* caller who really does want the phrase can ask for it. An unbalanced quote is
+* stripped rather than honoured — the alternative is that everything after a
+* stray `"` silently becomes one long term that matches nothing.
+*
+* Returns an empty array for a string with no terms in it at all (whitespace,
+* or nothing but quotes); the caller decides what an empty search means, since
+* only it knows whether "no constraint" or "no rows" is the safe reading.
+*/
+function splitSearchTerms(searchString, maxTerms = 8) {
+	const terms = [];
+	const pattern = /"([^"]*)"|(\S+)/g;
+	let match;
+	while ((match = pattern.exec(searchString)) !== null) {
+		const term = (match[1] ?? match[2].replace(/"/g, "")).trim();
+		if (!term) continue;
+		terms.push(term);
+		if (terms.length >= maxTerms) break;
+	}
+	return terms;
+}
+//#endregion
+export { suggestNearMiss as n, toSnakeCase as r, splitSearchTerms as t };
+
+//# sourceMappingURL=strings.es-B7QLnHh2.js.map

package/dist/strings.es-B7QLnHh2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strings.es-B7QLnHh2.js","names":[],"sources":["../../utils/dist/strings.es.js"],"sourcesContent":["//#region src/strings.ts\nvar tokenizeRegex = /[A-Z]{2,}(?=[A-Z][a-z]|\\b)|[A-Z]?[a-z]+|[0-9]+(?:[a-z](?![a-z]))?|[A-Z]/g;\nvar toKebabCase = (str) => {\n\tif (!str || typeof str !== \"string\") return \"\";\n\tconst regExpMatchArray = str.match(tokenizeRegex);\n\tif (!regExpMatchArray) return \"\";\n\treturn regExpMatchArray.map((x) => x.toLowerCase()).join(\"-\");\n};\nvar snakeCaseRegex = tokenizeRegex;\nvar toSnakeCase = (str) => {\n\tif (!str || typeof str !== \"string\") return \"\";\n\tconst regExpMatchArray = str.match(snakeCaseRegex);\n\tif (!regExpMatchArray) return \"\";\n\treturn regExpMatchArray.map((x) => x.toLowerCase()).join(\"_\");\n};\nfunction camelCase(str) {\n\tif (!str) return \"\";\n\tif (str.length === 1) return str.toLowerCase();\n\tconst parts = str.split(/[-_ ]+/).filter(Boolean);\n\tif (parts.length === 0) return \"\";\n\treturn parts[0].toLowerCase() + parts.slice(1).map((part) => part.charAt(0).toUpperCase() + part.substring(1).toLowerCase()).join(\"\");\n}\n/**\n* A random base-36 string of exactly `strLength` characters.\n*\n* Not `Math.random().toString(36).slice(2, 2 + strLength)`: that has no\n* guaranteed length. Base-36 of a double drops trailing zeros, so the source\n* string is short about once in 36 calls and the slice quietly returns fewer\n* characters than asked for — `randomString(10)` returning 9. These values\n* prefix uploaded filenames to keep them apart, so a short one is a likelier\n* collision, and it fails at the rate that makes a test look flaky.\n*/\nfunction randomString(strLength = 5) {\n\tconst alphabet = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\tlet result = \"\";\n\tfor (let i = 0; i < strLength; i++) result += alphabet.charAt(Math.floor(Math.random() * 36));\n\treturn result;\n}\nfunction randomColor() {\n\treturn Math.floor(Math.random() * 16777215).toString(16);\n}\nfunction slugify(text, separator = \"_\", lowercase = true) {\n\tif (!text) return \"\";\n\tconst from = \"ãàáäâẽèéëêìíïîõòóöôùúüûñç·/_,:;-\";\n\tconst to = `aaaaaeeeeeiiiiooooouuuunc${separator}${separator}${separator}${separator}${separator}${separator}${separator}`;\n\tfor (let i = 0, l = 32; i < l; i++) text = text.replace(new RegExp(from.charAt(i), \"g\"), to.charAt(i));\n\ttext = text.toString().trim().replace(/^\\s+|\\s+$/g, \"\").replace(/\\s+/g, separator).replace(/&/g, separator).replace(/[^\\w\\\\-]+/g, \"\").replace(new RegExp(\"\\\\\" + separator + \"\\\\\" + separator + \"+\", \"g\"), separator);\n\treturn lowercase ? text.toLowerCase() : text;\n}\nfunction unslugify(slug) {\n\tif (!slug) return \"\";\n\tif (slug.includes(\"-\") || slug.includes(\"_\") || !slug.includes(\" \")) return slug.replace(/[-_]/g, \" \").replace(/\\w\\S*/g, function(txt) {\n\t\treturn txt.charAt(0).toUpperCase() + txt.substring(1);\n\t}).trim();\n\telse return slug.trim();\n}\n/**\n* Are these two identifiers one edit apart, ignoring case?\n*\n* Tight on purpose. A suggester that fires on two edits offers `columnWidth`\n* for `colWith` and `readOnly` for `required`, and a \"did you mean\" that is\n* usually wrong teaches people to stop reading them. One edit covers what\n* actually happens — a dropped letter (`multilne`), a doubled one, a transposed\n* pair (`validaton`), a wrong case — and nothing else.\n*\n* Lives here rather than beside either caller because both the CLI's manifest\n* reader and the server's collection validator answer the same question about\n* an unknown key, and two copies of a similarity rule is two rules the moment\n* one of them is tuned.\n*/\nfunction isNearMiss(a, b) {\n\tconst x = a.toLowerCase();\n\tconst y = b.toLowerCase();\n\tif (x === y) return true;\n\tif (Math.abs(x.length - y.length) > 1) return false;\n\tconst [shorter, longer] = x.length <= y.length ? [x, y] : [y, x];\n\tlet i = 0;\n\tlet j = 0;\n\tlet edits = 0;\n\twhile (i < shorter.length && j < longer.length) {\n\t\tif (shorter[i] === longer[j]) {\n\t\t\ti++;\n\t\t\tj++;\n\t\t\tcontinue;\n\t\t}\n\t\tif (++edits > 1) return false;\n\t\tif (shorter.length === longer.length) i++;\n\t\tj++;\n\t}\n\treturn edits + (longer.length - j) + (shorter.length - i) <= 1;\n}\n/**\n* The key in `known` that `key` was probably meant to be, if any.\n*\n* `undefined` when nothing is close — which is the common case for a key that\n* is simply from a newer version, and the reason the caller must be able to say\n* \"unknown\" without saying \"wrong\".\n*/\nfunction suggestNearMiss(known, key) {\n\treturn known.find((candidate) => isNearMiss(candidate, key));\n}\nfunction prettifyIdentifier(input) {\n\tif (!input) return \"\";\n\tlet text = input;\n\ttext = text.replace(/([a-z])([A-Z])|([A-Z])([A-Z][a-z])/g, \"$1$3 $2$4\");\n\ttext = text.replace(/[_-]+/g, \" \");\n\treturn text.trim().replace(/\\b\\w/g, (char) => char.toUpperCase());\n}\n/**\n* How many terms one search string is allowed to contribute.\n*\n* Every term multiplies the work: the substring fallback compiles to one\n* `ILIKE '%term%'` per term *per searchable column*, evaluated per row on a\n* sequential scan. Eight is far past what a person types into a search box and\n* still bounds a pasted paragraph to a fixed number of predicates. Terms past\n* the cap are dropped rather than rejected — dropping only widens the result\n* set, and a search box that errors on a long paste is worse than one that\n* matches on its first eight words.\n*/\nvar MAX_SEARCH_TERMS = 8;\n/**\n* The terms a user meant when they typed into a search box.\n*\n* A search box is not a substring box. Typing `sebastian melendez` on a\n* collection whose name is split across `first_name` and `last_name` has to\n* find the row, and matching the whole string against each field separately\n* cannot: no single column holds both words. Splitting on whitespace and\n* requiring *every* term to match *some* field is what does, and it is what\n* `websearch_to_tsquery` already does for collections that declared a `search`\n* block — so this is also what keeps the two search paths answering the same\n* question.\n*\n* It fixes the trailing space too: `sebastian ` matched nothing at all, because\n* the space was part of the pattern.\n*\n* A double-quoted run is one term, again matching the full-text path, so a\n* caller who really does want the phrase can ask for it. An unbalanced quote is\n* stripped rather than honoured — the alternative is that everything after a\n* stray `\"` silently becomes one long term that matches nothing.\n*\n* Returns an empty array for a string with no terms in it at all (whitespace,\n* or nothing but quotes); the caller decides what an empty search means, since\n* only it knows whether \"no constraint\" or \"no rows\" is the safe reading.\n*/\nfunction splitSearchTerms(searchString, maxTerms = MAX_SEARCH_TERMS) {\n\tconst terms = [];\n\tconst pattern = /\"([^\"]*)\"|(\\S+)/g;\n\tlet match;\n\twhile ((match = pattern.exec(searchString)) !== null) {\n\t\tconst term = (match[1] ?? match[2].replace(/\"/g, \"\")).trim();\n\t\tif (!term) continue;\n\t\tterms.push(term);\n\t\tif (terms.length >= maxTerms) break;\n\t}\n\treturn terms;\n}\n//#endregion\nexport { MAX_SEARCH_TERMS, camelCase, isNearMiss, prettifyIdentifier, randomColor, randomString, slugify, splitSearchTerms, suggestNearMiss, toKebabCase, toSnakeCase, unslugify };\n\n//# sourceMappingURL=strings.es.js.map"],"mappings":";;;;AAQA,IAAI,iBAAiB;AACrB,IAAI,eAAe,QAAQ;CAC1B,IAAI,CAAC,OAAO,OAAO,QAAQ,UAAU,OAAO;CAC5C,MAAM,mBAAmB,IAAI,MAAM,cAAc;CACjD,IAAI,CAAC,kBAAkB,OAAO;CAC9B,OAAO,iBAAiB,KAAK,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,GAAG;AAC7D;;;;;;;;;;;;;;;AAwDA,SAAS,WAAW,GAAG,GAAG;CACzB,MAAM,IAAI,EAAE,YAAY;CACxB,MAAM,IAAI,EAAE,YAAY;CACxB,IAAI,MAAM,GAAG,OAAO;CACpB,IAAI,KAAK,IAAI,EAAE,SAAS,EAAE,MAAM,IAAI,GAAG,OAAO;CAC9C,MAAM,CAAC,SAAS,UAAU,EAAE,UAAU,EAAE,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC;CAC/D,IAAI,IAAI;CACR,IAAI,IAAI;CACR,IAAI,QAAQ;CACZ,OAAO,IAAI,QAAQ,UAAU,IAAI,OAAO,QAAQ;EAC/C,IAAI,QAAQ,OAAO,OAAO,IAAI;GAC7B;GACA;GACA;EACD;EACA,IAAI,EAAE,QAAQ,GAAG,OAAO;EACxB,IAAI,QAAQ,WAAW,OAAO,QAAQ;EACtC;CACD;CACA,OAAO,SAAS,OAAO,SAAS,MAAM,QAAQ,SAAS,MAAM;AAC9D;;;;;;;;AAQA,SAAS,gBAAgB,OAAO,KAAK;CACpC,OAAO,MAAM,MAAM,cAAc,WAAW,WAAW,GAAG,CAAC;AAC5D;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,SAAS,iBAAiB,cAAc,WAAA,GAA6B;CACpE,MAAM,QAAQ,CAAC;CACf,MAAM,UAAU;CAChB,IAAI;CACJ,QAAQ,QAAQ,QAAQ,KAAK,YAAY,OAAO,MAAM;EACrD,MAAM,QAAQ,MAAM,MAAM,MAAM,EAAE,CAAC,QAAQ,MAAM,EAAE,EAAA,CAAG,KAAK;EAC3D,IAAI,CAAC,MAAM;EACX,MAAM,KAAK,IAAI;EACf,IAAI,MAAM,UAAU,UAAU;CAC/B;CACA,OAAO;AACR"}