@aglyn/aglyn 1.0.0-beta.143

package/src/lib/app-utils/dataset-models.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/dataset-models.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 { validateCustomFieldValue } from '../plugin-manager/custom-fields'\nimport { type DatasetFieldEntry, humanizeDatasetFieldId } from './datasets'\n\n/**\n * Dataset models (AGL-177): the runtime promotion of the type-level\n * blueprint in `libs/shared/data/types/src/lib/dod.ts` (kept as the\n * referenced design doc — this module is the single runtime source of\n * truth). A model lives on the dataset doc\n * (`orgs/{orgId}/datasets/{id}.model`) and drives the typed editor, import\n * and site-restore validation, and the console and `/v1` record writes\n * through the shared `validateDocument`/`coerceDocumentValues` pair so they\n * can't disagree. Form submissions and automation steps write through\n * `buildDatasetRecordValues` instead, which stores each value as text and\n * validates nothing.\n *\n * Storage conventions (Firestore-safe): timestamps as epoch millis\n * numbers, coordinates as `{ latitude, longitude }`, `sorted` as arrays,\n * `map` as plain objects, references as target-document id strings.\n */\n\n/** dod.ts `FT.Tag` vocabulary plus `reference` (AGL-180 builds on it). */\nexport type DatasetFieldType =\n  | 'bool'\n  | 'bytes'\n  | 'timestamp'\n  | 'float'\n  | 'int32'\n  | 'int64'\n  | 'nil'\n  | 'text'\n  | 'coordinates'\n  | 'map'\n  | 'sorted'\n  | 'reference'\n\nexport const DATASET_FIELD_TYPES: DatasetFieldType[] = [\n  'text',\n  'bool',\n  'int32',\n  'int64',\n  'float',\n  'timestamp',\n  'coordinates',\n  'map',\n  'sorted',\n  'bytes',\n  'nil',\n  'reference',\n]\n\n/** Display names, mirroring dod.ts `lbl`. */\nexport const DATASET_FIELD_TYPE_LABELS: Record<DatasetFieldType, string> = {\n  text: 'Text',\n  bool: 'Boolean',\n  int32: 'Integer',\n  int64: 'Big integer',\n  float: 'Number',\n  timestamp: 'Date & time',\n  coordinates: 'Coordinates',\n  map: 'Map',\n  sorted: 'List',\n  bytes: 'Bytes',\n  nil: 'Null',\n  reference: 'Reference',\n}\n\n/**\n * Plain-JSON validation vocabulary (the dod.ts `Eval` shape, extended\n * with min/max and options, serialized flat instead of enum-keyed).\n */\nexport interface DatasetFieldValidation {\n  required?: boolean\n  /** Source of a RegExp applied to text values. */\n  regex?: string\n  /** Numbers/timestamps: value bound. Text: length bound. */\n  min?: number\n  max?: number\n  /** Enum: value must be one of these (text fields). */\n  options?: string[]\n}\n\nexport interface DatasetFieldDefinition {\n  /**\n   * Human-facing display label only. The stable reference id is the KEY in\n   * `DatasetModel.fields` (and `order`), NOT this name — bindings resolve\n   * `{{item.<fieldId>}}` against that key. The default id is derived from\n   * this name once at creation but is user-overridable (AGL-578); renaming\n   * the label afterwards never changes the id.\n   */\n  name: string\n  type: DatasetFieldType\n  /**\n   * Plugin-declared custom type riding this base type (AGL-434) — see\n   * plugin-manager/custom-fields. Unknown names degrade to the base type.\n   */\n  customType?: string\n  description?: string\n  required?: boolean\n  /** Default applied by editors when creating documents; never coerced. */\n  default?: unknown\n  validation?: DatasetFieldValidation\n  /**\n   * Reference fields (AGL-180): target collection + display field id.\n   * `multiple` stores a `sorted` array of FKeys (small-cardinality\n   * many-to-many per the dod.ts guidance); `onDelete` is the referenced-\n   * document delete policy (default `setNull` — never cascade in v2).\n   */\n  reference?: {\n    datasetId: string\n    displayFieldId?: string\n    multiple?: boolean\n    onDelete?: 'restrict' | 'setNull'\n  }\n}\n\nexport interface DatasetModel {\n  fields: Record<string, DatasetFieldDefinition>\n  /** Field ids in display order. */\n  order: string[]\n}\n\n/**\n * Migration shim (v1 → v2): datasets created before models carry flat\n * `fields: string[]` — derive a model where every column is an optional\n * text field whose id is the column name, so the editor and AGL-103\n * bindings keep working on unmigrated docs during rollout.\n */\nexport function deriveModelFromFields(fields: string[]): DatasetModel {\n  const model: DatasetModel = { fields: {}, order: [] }\n  for (const name of fields) {\n    // Raw snake_case ids read as titles in table headers and pickers;\n    // the id stays the stable key (AGL-558).\n    model.fields[name] = { name: humanizeDatasetFieldId(name), type: 'text' }\n    model.order.push(name)\n  }\n  return model\n}\n\n/**\n * Model from quick-creator entries (AGL-558): stable slug ids with the\n * human display names preserved — \"Roast preference\" → id\n * `roast_preference`, name \"Roast preference\".\n */\nexport function modelFromFieldEntries(\n  entries: readonly DatasetFieldEntry[],\n): DatasetModel {\n  const model: DatasetModel = { fields: {}, order: [] }\n  for (const entry of entries) {\n    model.fields[entry.id] = { name: entry.name, type: 'text' }\n    model.order.push(entry.id)\n  }\n  return model\n}\n\n/** The dataset's model, deriving one from v1 `fields` when absent. */\nexport function effectiveDatasetModel(dataset: {\n  model?: DatasetModel\n  fields?: string[]\n}): DatasetModel {\n  if (dataset.model?.fields && dataset.model.order?.length) {\n    return dataset.model\n  }\n  return deriveModelFromFields(dataset.fields ?? [])\n}\n\nconst isFiniteNumber = (value: unknown): value is number =>\n  typeof value === 'number' && Number.isFinite(value)\n\n/**\n * Validates a document's values against a model, returning fieldId →\n * human-readable error (empty object = valid). Values are expected in\n * storage form (see the module doc); use `coerceDocumentValues` first\n * when starting from user input strings.\n */\nexport function validateDocument(\n  model: DatasetModel,\n  values: Record<string, unknown>,\n): Record<string, string> {\n  const errors: Record<string, string> = {}\n  for (const fieldId of model.order) {\n    const field = model.fields[fieldId]\n    if (!field) continue\n    const value = values[fieldId]\n    const required = field.required || field.validation?.required\n    if (value == null || value === '') {\n      if (required) errors[fieldId] = `${field.name} is required`\n      continue\n    }\n    const rules = field.validation ?? {}\n    switch (field.type) {\n      case 'text': {\n        if (typeof value !== 'string') {\n          errors[fieldId] = `${field.name} must be text`\n          break\n        }\n        if (rules.min != null && value.length < rules.min) {\n          errors[fieldId] = `${field.name} must be at least ${rules.min} characters`\n        } else if (rules.max != null && value.length > rules.max) {\n          errors[fieldId] = `${field.name} must be at most ${rules.max} characters`\n        } else if (rules.regex) {\n          try {\n            if (!new RegExp(rules.regex).test(value)) {\n              errors[fieldId] = `${field.name} has an invalid format`\n            }\n          } catch {\n            // Broken pattern in the model never blocks writes.\n          }\n        }\n        if (\n          !errors[fieldId] &&\n          rules.options?.length &&\n          !rules.options.includes(value)\n        ) {\n          errors[fieldId] = `${field.name} must be one of: ${rules.options.join(', ')}`\n        }\n        break\n      }\n      case 'bool':\n        if (typeof value !== 'boolean') {\n          errors[fieldId] = `${field.name} must be true or false`\n        }\n        break\n      case 'int32':\n      case 'int64':\n        if (!isFiniteNumber(value) || !Number.isInteger(value)) {\n          errors[fieldId] = `${field.name} must be a whole number`\n          break\n        }\n        if (rules.min != null && value < rules.min) {\n          errors[fieldId] = `${field.name} must be ≥ ${rules.min}`\n        } else if (rules.max != null && value > rules.max) {\n          errors[fieldId] = `${field.name} must be ≤ ${rules.max}`\n        }\n        break\n      case 'float':\n      case 'timestamp':\n        if (!isFiniteNumber(value)) {\n          errors[fieldId] =\n            field.type === 'timestamp'\n              ? `${field.name} must be a date`\n              : `${field.name} must be a number`\n          break\n        }\n        if (rules.min != null && value < rules.min) {\n          errors[fieldId] = `${field.name} must be ≥ ${rules.min}`\n        } else if (rules.max != null && value > rules.max) {\n          errors[fieldId] = `${field.name} must be ≤ ${rules.max}`\n        }\n        break\n      case 'coordinates': {\n        const coordinates = value as { latitude?: unknown; longitude?: unknown }\n        if (\n          !isFiniteNumber(coordinates?.latitude) ||\n          !isFiniteNumber(coordinates?.longitude) ||\n          Math.abs(coordinates.latitude) > 90 ||\n          Math.abs(coordinates.longitude) > 180\n        ) {\n          errors[fieldId] = `${field.name} must be valid coordinates`\n        }\n        break\n      }\n      case 'sorted':\n        if (!Array.isArray(value)) {\n          errors[fieldId] = `${field.name} must be a list`\n        }\n        break\n      case 'map':\n        if (typeof value !== 'object' || Array.isArray(value)) {\n          errors[fieldId] = `${field.name} must be a map`\n        }\n        break\n      case 'reference':\n        if (field.reference?.multiple) {\n          if (\n            !Array.isArray(value) ||\n            value.some((entry) => typeof entry !== 'string' || !entry)\n          ) {\n            errors[fieldId] = `${field.name} must reference documents`\n          }\n        } else if (typeof value !== 'string' || !value) {\n          errors[fieldId] = `${field.name} must reference a document`\n        }\n        break\n      case 'bytes':\n      case 'nil':\n        break\n    }\n  }\n  // Custom field types (AGL-434): plugin validators run after the base\n  // checks, only on fields that passed them.\n  for (const fieldId of model.order) {\n    const field = model.fields[fieldId]\n    if (!field?.customType || errors[fieldId]) continue\n    const customError = validateCustomFieldValue(\n      field.customType,\n      values[fieldId],\n    )\n    if (customError) errors[fieldId] = `${field.name}: ${customError}`\n  }\n  return errors\n}\n\n/** Storage value → grid display string (AGL-179). */\nexport function formatDatasetValue(\n  field: DatasetFieldDefinition,\n  value: unknown,\n): string {\n  if (value == null || value === '') return ''\n  switch (field.type) {\n    case 'bool':\n      return value === true ? '✓' : value === false ? '—' : String(value)\n    case 'timestamp':\n      return isFiniteNumber(value)\n        ? new Date(value).toISOString().slice(0, 16).replace('T', ' ')\n        : String(value)\n    case 'coordinates': {\n      const coordinates = value as { latitude?: number; longitude?: number }\n      return isFiniteNumber(coordinates?.latitude) &&\n        isFiniteNumber(coordinates?.longitude)\n        ? `${coordinates.latitude}, ${coordinates.longitude}`\n        : String(value)\n    }\n    case 'sorted':\n      return Array.isArray(value) ? value.join(', ') : String(value)\n    case 'map':\n      try {\n        return JSON.stringify(value)\n      } catch {\n        return String(value)\n      }\n    default:\n      return String(value)\n  }\n}\n\n/**\n * Storage value → form-input string (AGL-179): the inverse of\n * `coerceDocumentValues` for populating type-appropriate inputs\n * (timestamps as `datetime-local` values, coordinates as \"lat, lon\").\n */\nexport function datasetValueToInput(\n  field: DatasetFieldDefinition,\n  value: unknown,\n): string {\n  if (value == null) return ''\n  if (field.type === 'timestamp' && isFiniteNumber(value)) {\n    return new Date(value).toISOString().slice(0, 16)\n  }\n  if (field.type === 'bool') {\n    return value === true ? 'true' : value === false ? 'false' : String(value)\n  }\n  if (field.type === 'coordinates' || field.type === 'sorted') {\n    return formatDatasetValue(field, value)\n  }\n  if (field.type === 'map') return formatDatasetValue(field, value)\n  return String(value)\n}\n\n/**\n * Coerces user-input strings (form fields, CSV cells) into storage form\n * per the field type. Unparseable input is passed through untouched so\n * `validateDocument` reports it instead of silently mangling it.\n */\nexport function coerceDocumentValues(\n  model: DatasetModel,\n  input: Record<string, unknown>,\n): Record<string, unknown> {\n  const values: Record<string, unknown> = {}\n  for (const fieldId of model.order) {\n    const field = model.fields[fieldId]\n    const raw = input[fieldId]\n    if (!field || raw == null || raw === '') continue\n    if (typeof raw !== 'string') {\n      values[fieldId] = raw\n      continue\n    }\n    switch (field.type) {\n      case 'bool':\n        values[fieldId] =\n          raw === 'true' ? true : raw === 'false' ? false : raw\n        break\n      case 'int32':\n      case 'int64': {\n        const parsed = Number(raw)\n        values[fieldId] = Number.isInteger(parsed) ? parsed : raw\n        break\n      }\n      case 'float': {\n        const parsed = Number(raw)\n        values[fieldId] = Number.isFinite(parsed) ? parsed : raw\n        break\n      }\n      case 'timestamp': {\n        const millis = Date.parse(raw)\n        values[fieldId] = Number.isFinite(millis) ? millis : raw\n        break\n      }\n      case 'coordinates': {\n        const [latitude, longitude] = raw.split(',').map((part) => Number(part.trim()))\n        values[fieldId] =\n          Number.isFinite(latitude) && Number.isFinite(longitude)\n            ? { latitude, longitude }\n            : raw\n        break\n      }\n      case 'sorted':\n        values[fieldId] = raw\n          .split(',')\n          .map((part) => part.trim())\n          .filter(Boolean)\n        break\n      case 'map':\n        try {\n          values[fieldId] = JSON.parse(raw)\n        } catch {\n          values[fieldId] = raw\n        }\n        break\n      case 'reference':\n        values[fieldId] = field.reference?.multiple\n          ? raw\n              .split(',')\n              .map((part) => part.trim())\n              .filter(Boolean)\n          : raw\n        break\n      default:\n        values[fieldId] = raw\n    }\n  }\n  return values\n}\n\n/**\n * Every reference id a record holds, flattened out of its `reference` fields\n * into one de-duplicated list.\n *\n * A reference field stores either a single target id or — when\n * `reference.multiple` is set — an array of them, and a model may declare\n * several. Both shapes flatten into the same list because the question asked\n * of it is never \"which field\", it is \"does this record still point at that\n * document\".\n *\n * Fields are read from `order` UNIONED with the keys of `fields`. Every other\n * pass over a model walks `order` alone, which is right for anything the user\n * sees — but a reference declared without a display slot still holds a real\n * FKey, and an integrity index that skipped it would under-report.\n */\nexport function datasetReferencedIds(\n  model: DatasetModel,\n  values: Record<string, unknown> | undefined,\n): string[] {\n  const ids = new Set<string>()\n  const fieldIds = new Set([\n    ...(model.order ?? []),\n    ...Object.keys(model.fields ?? {}),\n  ])\n  for (const fieldId of fieldIds) {\n    if (model.fields?.[fieldId]?.type !== 'reference') continue\n    const stored = values?.[fieldId]\n    for (const entry of Array.isArray(stored) ? stored : [stored]) {\n      const id = typeof entry === 'string' ? entry.trim() : ''\n      if (id) ids.add(id)\n    }\n  }\n  return [...ids]\n}\n\n/**\n * The integrity index a record write carries, so referential integrity can be\n * decided by a QUERY rather than by the rows a listener happened to fetch.\n *\n * Deleting a record has to answer \"is anything still pointing at this?\", and\n * `restrict` refuses the delete on a yes while `setNull` strips the FKey. That\n * question cannot be asked where the answer is stored: dataset fields are\n * user-defined, so `records.values` carries a deliberate index exemption in\n * `cloud/firebase-firestore.indexes.json` — auto-indexing an unbounded map\n * blows Firestore's per-document index-entry limit — and\n * `where('values.<fieldId>', '==', id)` is therefore FAILED_PRECONDITION.\n * Reading a page of records and filtering them in the browser answers only for\n * the rows in that page, which is a browse window standing in for a\n * correctness check: a reference held outside it reads as no reference at all,\n * the delete proceeds, and `restrict` silently fails to restrict.\n *\n * `referencedIds` is that same reference, denormalized to a top-level array\n * Firestore will index, so one `array-contains` reaches every record.\n *\n * ⚠️ OMITTED when a record references nothing, rather than written as `[]`.\n * `isNotEmpty` is served as `!= null` and an empty array is not null, so a\n * record stamped `[]` answers \"holds a reference\" for a dataset that holds\n * none.\n *\n * ⚠️ Spread this at EVERY write that sets a record's `values`. A write that\n * sets values without it leaves the index describing the PREVIOUS values, and\n * a stale integrity index is the exact failure it exists to prevent — with the\n * UI reporting the record as safe to delete. On a merging write use\n * `datasetIntegrityUpdate` instead: omission leaves a stale array in place\n * where clearing the last reference has to remove the field.\n */\nexport function datasetIntegrityFields(\n  model: DatasetModel,\n  values: Record<string, unknown> | undefined,\n): { referencedIds?: string[] } {\n  const referencedIds = datasetReferencedIds(model, values)\n  return referencedIds.length ? { referencedIds } : {}\n}\n\n/**\n * `datasetIntegrityFields` for a MERGING write (`update`, `set` with `merge`\n * or `mergeFields`), where leaving the field out preserves what is stored\n * rather than clearing it.\n *\n * A record whose last reference is cleared has to have the field REMOVED, or\n * it goes on answering the `array-contains` for a document it no longer points\n * at — a `restrict` that refuses a delete nothing is holding. `clear` is the\n * caller's delete sentinel: `deleteField()` in the web SDK,\n * `FieldValue.delete()` in the Admin SDK. It is passed in rather than imported\n * because this module is shared by both and must stay SDK-free.\n */\nexport function datasetIntegrityUpdate<TClear>(\n  model: DatasetModel,\n  values: Record<string, unknown> | undefined,\n  clear: TClear,\n): { referencedIds: string[] | TClear } {\n  const referencedIds = datasetReferencedIds(model, values)\n  return { referencedIds: referencedIds.length ? referencedIds : clear }\n}\n"],"names":["validateCustomFieldValue","humanizeDatasetFieldId","DATASET_FIELD_TYPES","DATASET_FIELD_TYPE_LABELS","text","bool","int32","int64","float","timestamp","coordinates","map","sorted","bytes","nil","reference","deriveModelFromFields","fields","model","order","name","type","push","modelFromFieldEntries","entries","entry","id","effectiveDatasetModel","dataset","length","isFiniteNumber","value","Number","isFinite","validateDocument","values","errors","fieldId","field","required","validation","rules","min","max","regex","RegExp","test","options","includes","join","isInteger","latitude","longitude","Math","abs","Array","isArray","multiple","some","customType","customError","formatDatasetValue","String","Date","toISOString","slice","replace","JSON","stringify","datasetValueToInput","coerceDocumentValues","input","raw","parsed","millis","parse","split","part","trim","filter","Boolean","datasetReferencedIds","ids","Set","fieldIds","Object","keys","stored","add","datasetIntegrityFields","referencedIds","datasetIntegrityUpdate","clear"],"mappings":"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"}

package/src/lib/app-utils/dataset-query.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @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.
+ */
+/**
+ * Dataset query layer (AGL-181): filter/sort/limit over typed documents,
+ * shared by the console editor and the tenant renderer's repeatable
+ * expansion. Deliberately evaluated IN MEMORY over the already-bounded
+ * reads (editor page / `REPEAT_MAX_RECORDS`) — the Firestore reality
+ * check from the issue: this sidesteps inequality-filter and composite-
+ * index constraints entirely, at the documented cost that documents
+ * beyond the fetch bound are never considered. The bound is explicit,
+ * never silently unbounded.
+ */
+import type { DatasetModel } from './dataset-models';
+export type DatasetQueryOp = '==' | '!=' | '>' | '>=' | '<' | '<=' | 'contains';
+export declare const DATASET_QUERY_OPS: DatasetQueryOp[];
+export interface DatasetQueryWhere {
+    fieldId: string;
+    op: DatasetQueryOp;
+    /** Literal, compared with type-aware coercion against stored values. */
+    value: string;
+}
+export interface DatasetQuery {
+    where?: DatasetQueryWhere[];
+    orderBy?: {
+        fieldId: string;
+        direction?: 'asc' | 'desc';
+    };
+    limit?: number;
+}
+/**
+ * Parses the authoring shorthand `field op value` (e.g. `price <= 20`,
+ * `tier == plus`, `tags contains red`). Null for unparseable input so
+ * callers fail open (no filter) rather than filtering wrongly.
+ */
+export declare function parseDatasetFilter(input: string): DatasetQueryWhere | null;
+/** Parses `field` or `field desc` into an orderBy config. */
+export declare function parseDatasetSort(input: string): DatasetQuery['orderBy'] | null;
+/**
+ * Applies where/orderBy/limit to in-memory rows. Where-clauses on fields
+ * absent from the model still run (stored-value comparison) so v1
+ * datasets work; timestamps compare numerically (epoch millis storage).
+ */
+export declare function applyDatasetQuery<Row extends Record<string, unknown>>(model: DatasetModel | undefined, rows: Row[], query: DatasetQuery): Row[];

package/src/lib/app-utils/dataset-query.js

@@ -0,0 +1,126 @@
+/**
+ * @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.
+ */ /**
+ * Dataset query layer (AGL-181): filter/sort/limit over typed documents,
+ * shared by the console editor and the tenant renderer's repeatable
+ * expansion. Deliberately evaluated IN MEMORY over the already-bounded
+ * reads (editor page / `REPEAT_MAX_RECORDS`) — the Firestore reality
+ * check from the issue: this sidesteps inequality-filter and composite-
+ * index constraints entirely, at the documented cost that documents
+ * beyond the fetch bound are never considered. The bound is explicit,
+ * never silently unbounded.
+ */ export const DATASET_QUERY_OPS = [
+    '==',
+    '!=',
+    '>',
+    '>=',
+    '<',
+    '<=',
+    'contains'
+];
+/**
+ * Parses the authoring shorthand `field op value` (e.g. `price <= 20`,
+ * `tier == plus`, `tags contains red`). Null for unparseable input so
+ * callers fail open (no filter) rather than filtering wrongly.
+ */ export function parseDatasetFilter(input) {
+    const match = String(input != null ? input : '').trim().match(/^([A-Za-z][A-Za-z0-9_]*)\s*(==|!=|>=|<=|>|<|contains)\s+(.+)$/);
+    if (!match) return null;
+    return {
+        fieldId: match[1],
+        op: match[2],
+        value: match[3].trim()
+    };
+}
+/** Parses `field` or `field desc` into an orderBy config. */ export function parseDatasetSort(input) {
+    var _match_;
+    const match = String(input != null ? input : '').trim().match(/^([A-Za-z][A-Za-z0-9_]*)(?:\s+(asc|desc))?$/i);
+    if (!match) return null;
+    return {
+        fieldId: match[1],
+        direction: ((_match_ = match[2]) == null ? void 0 : _match_.toLowerCase()) === 'desc' ? 'desc' : 'asc'
+    };
+}
+const comparable = (value)=>{
+    if (typeof value === 'number') return value;
+    if (typeof value === 'boolean') return value ? 1 : 0;
+    if (typeof value === 'string') {
+        const numeric = Number(value);
+        return Number.isFinite(numeric) && value.trim() !== '' ? numeric : value;
+    }
+    return null;
+};
+function matches(stored, where) {
+    const { op, value } = where;
+    if (op === 'contains') {
+        if (Array.isArray(stored)) {
+            return stored.some((entry)=>String(entry).toLowerCase() === value.toLowerCase());
+        }
+        return String(stored != null ? stored : '').toLowerCase().includes(value.toLowerCase());
+    }
+    if (op === '==' || op === '!=') {
+        const equal = typeof stored === 'boolean' ? String(stored) === value.toLowerCase() : String(stored != null ? stored : '') === value;
+        return op === '==' ? equal : !equal;
+    }
+    const left = comparable(stored);
+    const right = comparable(value);
+    if (left == null || right == null || typeof left !== typeof right) {
+        return false;
+    }
+    switch(op){
+        case '>':
+            return left > right;
+        case '>=':
+            return left >= right;
+        case '<':
+            return left < right;
+        case '<=':
+            return left <= right;
+    }
+    return false;
+}
+/**
+ * Applies where/orderBy/limit to in-memory rows. Where-clauses on fields
+ * absent from the model still run (stored-value comparison) so v1
+ * datasets work; timestamps compare numerically (epoch millis storage).
+ */ export function applyDatasetQuery(model, rows, query) {
+    var _query_where;
+    let result = rows;
+    for (const where of (_query_where = query.where) != null ? _query_where : []){
+        result = result.filter((row)=>matches(row[where.fieldId], where));
+    }
+    if (query.orderBy) {
+        const { fieldId, direction } = query.orderBy;
+        const sign = direction === 'desc' ? -1 : 1;
+        result = [
+            ...result
+        ].sort((a, b)=>{
+            const left = comparable(a[fieldId]);
+            const right = comparable(b[fieldId]);
+            if (left == null) return 1;
+            if (right == null) return -1;
+            if (typeof left === 'number' && typeof right === 'number') {
+                return (left - right) * sign;
+            }
+            return String(left).localeCompare(String(right)) * sign;
+        });
+    }
+    if (query.limit != null && query.limit > 0) {
+        result = result.slice(0, query.limit);
+    }
+    return result;
+}
+
+//# sourceMappingURL=dataset-query.js.map

package/src/lib/app-utils/dataset-query.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/dataset-query.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\n/**\n * Dataset query layer (AGL-181): filter/sort/limit over typed documents,\n * shared by the console editor and the tenant renderer's repeatable\n * expansion. Deliberately evaluated IN MEMORY over the already-bounded\n * reads (editor page / `REPEAT_MAX_RECORDS`) — the Firestore reality\n * check from the issue: this sidesteps inequality-filter and composite-\n * index constraints entirely, at the documented cost that documents\n * beyond the fetch bound are never considered. The bound is explicit,\n * never silently unbounded.\n */\n\nimport type { DatasetModel } from './dataset-models'\n\nexport type DatasetQueryOp =\n  | '=='\n  | '!='\n  | '>'\n  | '>='\n  | '<'\n  | '<='\n  | 'contains'\n\nexport const DATASET_QUERY_OPS: DatasetQueryOp[] = [\n  '==',\n  '!=',\n  '>',\n  '>=',\n  '<',\n  '<=',\n  'contains',\n]\n\nexport interface DatasetQueryWhere {\n  fieldId: string\n  op: DatasetQueryOp\n  /** Literal, compared with type-aware coercion against stored values. */\n  value: string\n}\n\nexport interface DatasetQuery {\n  where?: DatasetQueryWhere[]\n  orderBy?: { fieldId: string; direction?: 'asc' | 'desc' }\n  limit?: number\n}\n\n/**\n * Parses the authoring shorthand `field op value` (e.g. `price <= 20`,\n * `tier == plus`, `tags contains red`). Null for unparseable input so\n * callers fail open (no filter) rather than filtering wrongly.\n */\nexport function parseDatasetFilter(input: string): DatasetQueryWhere | null {\n  const match = String(input ?? '')\n    .trim()\n    .match(/^([A-Za-z][A-Za-z0-9_]*)\\s*(==|!=|>=|<=|>|<|contains)\\s+(.+)$/)\n  if (!match) return null\n  return {\n    fieldId: match[1],\n    op: match[2] as DatasetQueryOp,\n    value: match[3].trim(),\n  }\n}\n\n/** Parses `field` or `field desc` into an orderBy config. */\nexport function parseDatasetSort(\n  input: string,\n): DatasetQuery['orderBy'] | null {\n  const match = String(input ?? '')\n    .trim()\n    .match(/^([A-Za-z][A-Za-z0-9_]*)(?:\\s+(asc|desc))?$/i)\n  if (!match) return null\n  return {\n    fieldId: match[1],\n    direction: match[2]?.toLowerCase() === 'desc' ? 'desc' : 'asc',\n  }\n}\n\nconst comparable = (value: unknown): number | string | null => {\n  if (typeof value === 'number') return value\n  if (typeof value === 'boolean') return value ? 1 : 0\n  if (typeof value === 'string') {\n    const numeric = Number(value)\n    return Number.isFinite(numeric) && value.trim() !== '' ? numeric : value\n  }\n  return null\n}\n\nfunction matches(stored: unknown, where: DatasetQueryWhere): boolean {\n  const { op, value } = where\n  if (op === 'contains') {\n    if (Array.isArray(stored)) {\n      return stored.some(\n        (entry) => String(entry).toLowerCase() === value.toLowerCase(),\n      )\n    }\n    return String(stored ?? '')\n      .toLowerCase()\n      .includes(value.toLowerCase())\n  }\n  if (op === '==' || op === '!=') {\n    const equal =\n      typeof stored === 'boolean'\n        ? String(stored) === value.toLowerCase()\n        : String(stored ?? '') === value\n    return op === '==' ? equal : !equal\n  }\n  const left = comparable(stored)\n  const right = comparable(value)\n  if (left == null || right == null || typeof left !== typeof right) {\n    return false\n  }\n  switch (op) {\n    case '>':\n      return left > right\n    case '>=':\n      return left >= right\n    case '<':\n      return left < right\n    case '<=':\n      return left <= right\n  }\n  return false\n}\n\n/**\n * Applies where/orderBy/limit to in-memory rows. Where-clauses on fields\n * absent from the model still run (stored-value comparison) so v1\n * datasets work; timestamps compare numerically (epoch millis storage).\n */\nexport function applyDatasetQuery<Row extends Record<string, unknown>>(\n  model: DatasetModel | undefined,\n  rows: Row[],\n  query: DatasetQuery,\n): Row[] {\n  let result = rows\n  for (const where of query.where ?? []) {\n    result = result.filter((row) => matches(row[where.fieldId], where))\n  }\n  if (query.orderBy) {\n    const { fieldId, direction } = query.orderBy\n    const sign = direction === 'desc' ? -1 : 1\n    result = [...result].sort((a, b) => {\n      const left = comparable(a[fieldId])\n      const right = comparable(b[fieldId])\n      if (left == null) return 1\n      if (right == null) return -1\n      if (typeof left === 'number' && typeof right === 'number') {\n        return (left - right) * sign\n      }\n      return String(left).localeCompare(String(right)) * sign\n    })\n  }\n  if (query.limit != null && query.limit > 0) {\n    result = result.slice(0, query.limit)\n  }\n  return result\n}\n"],"names":["DATASET_QUERY_OPS","parseDatasetFilter","input","match","String","trim","fieldId","op","value","parseDatasetSort","direction","toLowerCase","comparable","numeric","Number","isFinite","matches","stored","where","Array","isArray","some","entry","includes","equal","left","right","applyDatasetQuery","model","rows","query","result","filter","row","orderBy","sign","sort","a","b","localeCompare","limit","slice"],"mappings":"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"}

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

@@ -0,0 +1,136 @@
+/**
+ * @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.
+ */
+/**
+ * Datasets (AGL-102): tabular data at `orgs/{orgId}/datasets/{id}` with a
+ * `records` subcollection, edited in the console Data card and consumed by
+ * repeatable components (AGL-103) via `{{item.field}}` bindings.
+ */
+import { type DatasetModel } from './dataset-models';
+/** Dataset field name: starts with a letter; letters/digits/underscores. */
+export declare const DATASET_FIELD_PATTERN: RegExp;
+export interface HostDataset {
+    $id?: string;
+    displayName?: string;
+    /** Column names, in display order (v1; superseded by `model`). */
+    fields?: string[];
+    /** Typed model (AGL-177); when absent, derive from `fields`. */
+    model?: import('./dataset-models').DatasetModel;
+    /** dod.ts Schema.Name shape (AGL-178). */
+    names?: {
+        singular?: string;
+        plural?: string;
+    };
+    /**
+     * Which sites may see this dataset (AGL-1037). Absent = org-wide, until
+     * the AGL-1040 backfill stamps it. See `app-utils/scope-tokens`.
+     */
+    visibleTo?: import('../foundation').ScopeToken[];
+}
+export interface HostDatasetRecord {
+    $id?: string;
+    /** Field → display value. */
+    values?: Record<string, string>;
+    /** Row position in the editor and in repeated output. */
+    order?: number;
+}
+/**
+ * A human field entry from the quick creator: the stable id plus the
+ * display name shown in table headers and bindings pickers (AGL-558).
+ */
+export interface DatasetFieldEntry {
+    id: string;
+    name: string;
+}
+/**
+ * Stable field id from a human name: "Roast preference" → "roast_preference".
+ * Mirrors DATASET_FIELD_PATTERN; returns '' when nothing salvageable.
+ */
+export declare function slugifyDatasetFieldId(name: string): string;
+/**
+ * Default reference id for a new field (AGL-578): the `slugifyDatasetFieldId`
+ * slug, suffixed (`_2`, `_3`, …) to stay unique within the dataset. `taken`
+ * holds the ids already in use (compared case-insensitively). Returns '' when
+ * the name yields nothing valid. The user can override the result.
+ */
+export declare function defaultDatasetFieldId(name: string, taken: ReadonlySet<string>): string;
+/**
+ * Validate a user-entered reference id (AGL-578): non-empty, matches
+ * `DATASET_FIELD_PATTERN`, and unique within the dataset (`taken` = ids already
+ * used, compared case-insensitively). Returns an error message, or null when
+ * the id is usable.
+ */
+export declare function validateDatasetFieldId(id: string, taken: ReadonlySet<string>): string | null;
+/** Display fallback for raw ids: "roast_preference" → "Roast preference". */
+export declare function humanizeDatasetFieldId(id: string): string;
+/**
+ * Parses a comma/newline separated list of HUMAN field names into
+ * {id, name} entries — "Roast preference" keeps its pretty name and gets
+ * the stable id `roast_preference` (AGL-558). Plain snake_case keys
+ * still work and pick up a humanized display name. Duplicate ids and
+ * unsalvageable entries are dropped rather than failing the set.
+ */
+export declare function parseDatasetFieldEntries(input: string): DatasetFieldEntry[];
+/**
+ * Parses a comma/newline separated field list into valid unique names;
+ * invalid entries are dropped rather than failing the whole set.
+ */
+export declare function parseDatasetFields(input: string): string[];
+/** Record values restricted to the dataset's declared fields. */
+export declare function sanitizeRecordValues(fields: string[], input: Record<string, unknown> | null | undefined): Record<string, string>;
+/**
+ * Record values for a dataset write (AGL-556). With a `fieldMap`
+ * (submitted key → stable model fieldId), mapped values are stored under
+ * the mapped fieldId — so renamed schema fields keep receiving data — and
+ * entries whose fieldId isn't in the model are dropped (the map is
+ * client-supplied and never trusted). Submitted keys without a mapping
+ * (and calls without a map) fall back to the legacy name-intersection
+ * against the model's field ids, matching `sanitizeRecordValues`.
+ */
+export declare function buildDatasetRecordValues(dataset: {
+    model?: DatasetModel;
+    fields?: string[];
+}, input: Record<string, unknown> | null | undefined, fieldMap?: Record<string, string> | null): Record<string, string>;
+/**
+ * The name a dataset is shown under: `displayName`, which is what every create
+ * path writes (AGL-536), then the pre-migration `name`. Blank when the document
+ * carries neither.
+ */
+export declare function datasetDisplayName(dataset: {
+    displayName?: unknown;
+    name?: unknown;
+} | null | undefined): string;
+/** One entry in a dataset select: stored by id, shown by name. */
+export interface DatasetPickerOption {
+    id: string;
+    name: string;
+}
+/**
+ * The options a dataset select offers, sorted by the label shown.
+ *
+ * Deleted datasets are left out. Each is labeled by
+ * {@link datasetDisplayName}; one whose document carries no name at all is
+ * offered under its id, because a select that hides it leaves a dataset that
+ * cannot be picked.
+ */
+export declare function datasetPickerOptions(docs: ReadonlyArray<{
+    $id?: string;
+    deletedAt?: unknown;
+    displayName?: unknown;
+    name?: unknown;
+}> | null | undefined): DatasetPickerOption[];
+/** Records sorted by their editor order (then id for stability). */
+export declare function sortDatasetRecords<T extends HostDatasetRecord>(records: T[]): T[];

package/src/lib/app-utils/datasets.js

@@ -0,0 +1,177 @@
+/**
+ * @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.
+ */ /**
+ * Datasets (AGL-102): tabular data at `orgs/{orgId}/datasets/{id}` with a
+ * `records` subcollection, edited in the console Data card and consumed by
+ * repeatable components (AGL-103) via `{{item.field}}` bindings.
+ */ import { effectiveDatasetModel } from "./dataset-models.js";
+/** Dataset field name: starts with a letter; letters/digits/underscores. */ export const DATASET_FIELD_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/;
+/**
+ * Stable field id from a human name: "Roast preference" → "roast_preference".
+ * Mirrors DATASET_FIELD_PATTERN; returns '' when nothing salvageable.
+ */ export function slugifyDatasetFieldId(name) {
+    const slug = name.trim().toLowerCase().replace(/[\s-]+/g, '_').replace(/[^a-z0-9_]/g, '').replace(/^[0-9_]+/, '').replace(/_+$/, '');
+    return DATASET_FIELD_PATTERN.test(slug) ? slug : '';
+}
+/**
+ * Default reference id for a new field (AGL-578): the `slugifyDatasetFieldId`
+ * slug, suffixed (`_2`, `_3`, …) to stay unique within the dataset. `taken`
+ * holds the ids already in use (compared case-insensitively). Returns '' when
+ * the name yields nothing valid. The user can override the result.
+ */ export function defaultDatasetFieldId(name, taken) {
+    const base = slugifyDatasetFieldId(name);
+    if (!base) return '';
+    const used = new Set([
+        ...taken
+    ].map((id)=>id.toLowerCase()));
+    let candidate = base;
+    let suffix = 2;
+    while(used.has(candidate.toLowerCase()))candidate = `${base}_${suffix++}`;
+    return candidate;
+}
+/**
+ * Validate a user-entered reference id (AGL-578): non-empty, matches
+ * `DATASET_FIELD_PATTERN`, and unique within the dataset (`taken` = ids already
+ * used, compared case-insensitively). Returns an error message, or null when
+ * the id is usable.
+ */ export function validateDatasetFieldId(id, taken) {
+    const trimmed = id.trim();
+    if (!trimmed) return 'A reference ID is required';
+    if (!DATASET_FIELD_PATTERN.test(trimmed)) return 'Start with a letter; use only letters, numbers, and underscores';
+    const used = new Set([
+        ...taken
+    ].map((existing)=>existing.toLowerCase()));
+    if (used.has(trimmed.toLowerCase())) return 'Another field already uses this reference ID';
+    return null;
+}
+/** Display fallback for raw ids: "roast_preference" → "Roast preference". */ export function humanizeDatasetFieldId(id) {
+    const words = id.replace(/_/g, ' ').trim();
+    return words ? words.charAt(0).toUpperCase() + words.slice(1) : id;
+}
+/**
+ * Parses a comma/newline separated list of HUMAN field names into
+ * {id, name} entries — "Roast preference" keeps its pretty name and gets
+ * the stable id `roast_preference` (AGL-558). Plain snake_case keys
+ * still work and pick up a humanized display name. Duplicate ids and
+ * unsalvageable entries are dropped rather than failing the set.
+ */ export function parseDatasetFieldEntries(input) {
+    const seen = new Set();
+    const entries = [];
+    for (const raw of input.split(/[,\n]/)){
+        const trimmed = raw.trim();
+        if (!trimmed) continue;
+        const id = slugifyDatasetFieldId(trimmed);
+        if (!id || seen.has(id)) continue;
+        seen.add(id);
+        entries.push({
+            id,
+            name: DATASET_FIELD_PATTERN.test(trimmed) ? humanizeDatasetFieldId(trimmed) : trimmed
+        });
+    }
+    return entries;
+}
+/**
+ * Parses a comma/newline separated field list into valid unique names;
+ * invalid entries are dropped rather than failing the whole set.
+ */ export function parseDatasetFields(input) {
+    const seen = new Set();
+    const fields = [];
+    for (const raw of input.split(/[,\n]/)){
+        const name = raw.trim();
+        if (!DATASET_FIELD_PATTERN.test(name)) continue;
+        const key = name.toLowerCase();
+        if (seen.has(key)) continue;
+        seen.add(key);
+        fields.push(name);
+    }
+    return fields;
+}
+/** Record values restricted to the dataset's declared fields. */ export function sanitizeRecordValues(fields, input) {
+    const values = {};
+    for (const field of fields){
+        const value = input == null ? void 0 : input[field];
+        if (value == null) continue;
+        values[field] = String(value);
+    }
+    return values;
+}
+/**
+ * Record values for a dataset write (AGL-556). With a `fieldMap`
+ * (submitted key → stable model fieldId), mapped values are stored under
+ * the mapped fieldId — so renamed schema fields keep receiving data — and
+ * entries whose fieldId isn't in the model are dropped (the map is
+ * client-supplied and never trusted). Submitted keys without a mapping
+ * (and calls without a map) fall back to the legacy name-intersection
+ * against the model's field ids, matching `sanitizeRecordValues`.
+ */ export function buildDatasetRecordValues(dataset, input, fieldMap) {
+    const model = effectiveDatasetModel(dataset);
+    const map = fieldMap != null ? fieldMap : {};
+    const values = {};
+    for (const fieldId of model.order){
+        if (!model.fields[fieldId]) continue;
+        // A submitted key with an explicit mapping never doubles as a
+        // name-match — the mapping decides where it lands.
+        if (fieldId in map) continue;
+        const value = input == null ? void 0 : input[fieldId];
+        if (value == null) continue;
+        values[fieldId] = String(value);
+    }
+    for (const [submittedKey, fieldId] of Object.entries(map)){
+        if (typeof fieldId !== 'string' || !model.fields[fieldId]) continue;
+        const value = input == null ? void 0 : input[submittedKey];
+        if (value == null) continue;
+        values[fieldId] = String(value);
+    }
+    return values;
+}
+/**
+ * The name a dataset is shown under: `displayName`, which is what every create
+ * path writes (AGL-536), then the pre-migration `name`. Blank when the document
+ * carries neither.
+ */ export function datasetDisplayName(dataset) {
+    for (const candidate of [
+        dataset == null ? void 0 : dataset.displayName,
+        dataset == null ? void 0 : dataset.name
+    ]){
+        if (typeof candidate === 'string' && candidate.trim()) {
+            return candidate.trim();
+        }
+    }
+    return '';
+}
+/**
+ * The options a dataset select offers, sorted by the label shown.
+ *
+ * Deleted datasets are left out. Each is labeled by
+ * {@link datasetDisplayName}; one whose document carries no name at all is
+ * offered under its id, because a select that hides it leaves a dataset that
+ * cannot be picked.
+ */ export function datasetPickerOptions(docs) {
+    return (docs != null ? docs : []).filter((dataset)=>!dataset.deletedAt && dataset.$id).map((dataset)=>({
+            id: dataset.$id,
+            name: datasetDisplayName(dataset) || dataset.$id
+        })).sort((a, b)=>a.name.localeCompare(b.name));
+}
+/** Records sorted by their editor order (then id for stability). */ export function sortDatasetRecords(records) {
+    return [
+        ...records
+    ].sort((a, b)=>{
+        var _a_order, _b_order, _a_$id, _b_$id;
+        return ((_a_order = a.order) != null ? _a_order : Number.MAX_SAFE_INTEGER) - ((_b_order = b.order) != null ? _b_order : Number.MAX_SAFE_INTEGER) || String((_a_$id = a.$id) != null ? _a_$id : '').localeCompare(String((_b_$id = b.$id) != null ? _b_$id : ''));
+    });
+}
+
+//# sourceMappingURL=datasets.js.map

package/src/lib/app-utils/datasets.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/datasets.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\n/**\n * Datasets (AGL-102): tabular data at `orgs/{orgId}/datasets/{id}` with a\n * `records` subcollection, edited in the console Data card and consumed by\n * repeatable components (AGL-103) via `{{item.field}}` bindings.\n */\n\nimport {\n  type DatasetModel,\n  effectiveDatasetModel,\n} from './dataset-models'\n\n/** Dataset field name: starts with a letter; letters/digits/underscores. */\nexport const DATASET_FIELD_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/\n\nexport interface HostDataset {\n  $id?: string\n  displayName?: string\n  /** Column names, in display order (v1; superseded by `model`). */\n  fields?: string[]\n  /** Typed model (AGL-177); when absent, derive from `fields`. */\n  model?: import('./dataset-models').DatasetModel\n  /** dod.ts Schema.Name shape (AGL-178). */\n  names?: { singular?: string; plural?: string }\n  /**\n   * Which sites may see this dataset (AGL-1037). Absent = org-wide, until\n   * the AGL-1040 backfill stamps it. See `app-utils/scope-tokens`.\n   */\n  visibleTo?: import('../foundation').ScopeToken[]\n}\n\nexport interface HostDatasetRecord {\n  $id?: string\n  /** Field → display value. */\n  values?: Record<string, string>\n  /** Row position in the editor and in repeated output. */\n  order?: number\n}\n\n/**\n * A human field entry from the quick creator: the stable id plus the\n * display name shown in table headers and bindings pickers (AGL-558).\n */\nexport interface DatasetFieldEntry {\n  id: string\n  name: string\n}\n\n/**\n * Stable field id from a human name: \"Roast preference\" → \"roast_preference\".\n * Mirrors DATASET_FIELD_PATTERN; returns '' when nothing salvageable.\n */\nexport function slugifyDatasetFieldId(name: string): string {\n  const slug = name\n    .trim()\n    .toLowerCase()\n    .replace(/[\\s-]+/g, '_')\n    .replace(/[^a-z0-9_]/g, '')\n    .replace(/^[0-9_]+/, '')\n    .replace(/_+$/, '')\n  return DATASET_FIELD_PATTERN.test(slug) ? slug : ''\n}\n\n/**\n * Default reference id for a new field (AGL-578): the `slugifyDatasetFieldId`\n * slug, suffixed (`_2`, `_3`, …) to stay unique within the dataset. `taken`\n * holds the ids already in use (compared case-insensitively). Returns '' when\n * the name yields nothing valid. The user can override the result.\n */\nexport function defaultDatasetFieldId(\n  name: string,\n  taken: ReadonlySet<string>,\n): string {\n  const base = slugifyDatasetFieldId(name)\n  if (!base) return ''\n  const used = new Set([...taken].map((id) => id.toLowerCase()))\n  let candidate = base\n  let suffix = 2\n  while (used.has(candidate.toLowerCase())) candidate = `${base}_${suffix++}`\n  return candidate\n}\n\n/**\n * Validate a user-entered reference id (AGL-578): non-empty, matches\n * `DATASET_FIELD_PATTERN`, and unique within the dataset (`taken` = ids already\n * used, compared case-insensitively). Returns an error message, or null when\n * the id is usable.\n */\nexport function validateDatasetFieldId(\n  id: string,\n  taken: ReadonlySet<string>,\n): string | null {\n  const trimmed = id.trim()\n  if (!trimmed) return 'A reference ID is required'\n  if (!DATASET_FIELD_PATTERN.test(trimmed))\n    return 'Start with a letter; use only letters, numbers, and underscores'\n  const used = new Set([...taken].map((existing) => existing.toLowerCase()))\n  if (used.has(trimmed.toLowerCase()))\n    return 'Another field already uses this reference ID'\n  return null\n}\n\n/** Display fallback for raw ids: \"roast_preference\" → \"Roast preference\". */\nexport function humanizeDatasetFieldId(id: string): string {\n  const words = id.replace(/_/g, ' ').trim()\n  return words ? words.charAt(0).toUpperCase() + words.slice(1) : id\n}\n\n/**\n * Parses a comma/newline separated list of HUMAN field names into\n * {id, name} entries — \"Roast preference\" keeps its pretty name and gets\n * the stable id `roast_preference` (AGL-558). Plain snake_case keys\n * still work and pick up a humanized display name. Duplicate ids and\n * unsalvageable entries are dropped rather than failing the set.\n */\nexport function parseDatasetFieldEntries(input: string): DatasetFieldEntry[] {\n  const seen = new Set<string>()\n  const entries: DatasetFieldEntry[] = []\n  for (const raw of input.split(/[,\\n]/)) {\n    const trimmed = raw.trim()\n    if (!trimmed) continue\n    const id = slugifyDatasetFieldId(trimmed)\n    if (!id || seen.has(id)) continue\n    seen.add(id)\n    entries.push({\n      id,\n      name: DATASET_FIELD_PATTERN.test(trimmed)\n        ? humanizeDatasetFieldId(trimmed)\n        : trimmed,\n    })\n  }\n  return entries\n}\n\n/**\n * Parses a comma/newline separated field list into valid unique names;\n * invalid entries are dropped rather than failing the whole set.\n */\nexport function parseDatasetFields(input: string): string[] {\n  const seen = new Set<string>()\n  const fields: string[] = []\n  for (const raw of input.split(/[,\\n]/)) {\n    const name = raw.trim()\n    if (!DATASET_FIELD_PATTERN.test(name)) continue\n    const key = name.toLowerCase()\n    if (seen.has(key)) continue\n    seen.add(key)\n    fields.push(name)\n  }\n  return fields\n}\n\n/** Record values restricted to the dataset's declared fields. */\nexport function sanitizeRecordValues(\n  fields: string[],\n  input: Record<string, unknown> | null | undefined,\n): Record<string, string> {\n  const values: Record<string, string> = {}\n  for (const field of fields) {\n    const value = input?.[field]\n    if (value == null) continue\n    values[field] = String(value)\n  }\n  return values\n}\n\n/**\n * Record values for a dataset write (AGL-556). With a `fieldMap`\n * (submitted key → stable model fieldId), mapped values are stored under\n * the mapped fieldId — so renamed schema fields keep receiving data — and\n * entries whose fieldId isn't in the model are dropped (the map is\n * client-supplied and never trusted). Submitted keys without a mapping\n * (and calls without a map) fall back to the legacy name-intersection\n * against the model's field ids, matching `sanitizeRecordValues`.\n */\nexport function buildDatasetRecordValues(\n  dataset: { model?: DatasetModel; fields?: string[] },\n  input: Record<string, unknown> | null | undefined,\n  fieldMap?: Record<string, string> | null,\n): Record<string, string> {\n  const model = effectiveDatasetModel(dataset)\n  const map = fieldMap ?? {}\n  const values: Record<string, string> = {}\n  for (const fieldId of model.order) {\n    if (!model.fields[fieldId]) continue\n    // A submitted key with an explicit mapping never doubles as a\n    // name-match — the mapping decides where it lands.\n    if (fieldId in map) continue\n    const value = input?.[fieldId]\n    if (value == null) continue\n    values[fieldId] = String(value)\n  }\n  for (const [submittedKey, fieldId] of Object.entries(map)) {\n    if (typeof fieldId !== 'string' || !model.fields[fieldId]) continue\n    const value = input?.[submittedKey]\n    if (value == null) continue\n    values[fieldId] = String(value)\n  }\n  return values\n}\n\n/**\n * The name a dataset is shown under: `displayName`, which is what every create\n * path writes (AGL-536), then the pre-migration `name`. Blank when the document\n * carries neither.\n */\nexport function datasetDisplayName(\n  dataset: { displayName?: unknown; name?: unknown } | null | undefined,\n): string {\n  for (const candidate of [dataset?.displayName, dataset?.name]) {\n    if (typeof candidate === 'string' && candidate.trim()) {\n      return candidate.trim()\n    }\n  }\n  return ''\n}\n\n/** One entry in a dataset select: stored by id, shown by name. */\nexport interface DatasetPickerOption {\n  id: string\n  name: string\n}\n\n/**\n * The options a dataset select offers, sorted by the label shown.\n *\n * Deleted datasets are left out. Each is labeled by\n * {@link datasetDisplayName}; one whose document carries no name at all is\n * offered under its id, because a select that hides it leaves a dataset that\n * cannot be picked.\n */\nexport function datasetPickerOptions(\n  docs:\n    | ReadonlyArray<{\n        $id?: string\n        deletedAt?: unknown\n        displayName?: unknown\n        name?: unknown\n      }>\n    | null\n    | undefined,\n): DatasetPickerOption[] {\n  return (docs ?? [])\n    .filter((dataset) => !dataset.deletedAt && dataset.$id)\n    .map((dataset) => ({\n      id: dataset.$id as string,\n      name: datasetDisplayName(dataset) || (dataset.$id as string),\n    }))\n    .sort((a, b) => a.name.localeCompare(b.name))\n}\n\n/** Records sorted by their editor order (then id for stability). */\nexport function sortDatasetRecords<T extends HostDatasetRecord>(\n  records: T[],\n): T[] {\n  return [...records].sort(\n    (a, b) =>\n      (a.order ?? Number.MAX_SAFE_INTEGER) -\n        (b.order ?? Number.MAX_SAFE_INTEGER) ||\n      String(a.$id ?? '').localeCompare(String(b.$id ?? '')),\n  )\n}\n"],"names":["effectiveDatasetModel","DATASET_FIELD_PATTERN","slugifyDatasetFieldId","name","slug","trim","toLowerCase","replace","test","defaultDatasetFieldId","taken","base","used","Set","map","id","candidate","suffix","has","validateDatasetFieldId","trimmed","existing","humanizeDatasetFieldId","words","charAt","toUpperCase","slice","parseDatasetFieldEntries","input","seen","entries","raw","split","add","push","parseDatasetFields","fields","key","sanitizeRecordValues","values","field","value","String","buildDatasetRecordValues","dataset","fieldMap","model","fieldId","order","submittedKey","Object","datasetDisplayName","displayName","datasetPickerOptions","docs","filter","deletedAt","$id","sort","a","b","localeCompare","sortDatasetRecords","records","Number","MAX_SAFE_INTEGER"],"mappings":"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"}