@aglyn/plugins-ai 1.0.0-beta.264 → 1.0.0-beta.268

package/src/lib/jobs/ai-job-site-datasets.d.ts

@@ -15,7 +15,8 @@
  * limitations under the License.
  */
 import { pluginResourceDraftWriter } from '@aglyn/aglyn/plugin-manager/plugin-resource-drafts';
-import { type AiBuildPlanCreate, type AiBuildPlanScreen } from '../model/ai-build-plan';
+import { type AiBuildPlan, type AiBuildPlanCreate, type AiBuildPlanScreen } from '../model/ai-build-plan';
+import type { AiInventoryDataset, AiSiteInventory } from '../model/ai-site-inventory';
 import type { AiJob, AiJobOutput, AiJobPlan } from '../model/ai-jobs.types';
 import type { AiPlanCapabilities } from '../model/ai-plan-capabilities';
 import { generateAiDataset } from '../runtime/ai-dataset-generation';
@@ -175,6 +176,8 @@ export declare function aiSiteDatasetRecordPhotos(input: {
     name: string;
     /** Each record's name, by position. */
     names: readonly string[];
+    /** What each record is filed under, by position ({@link aiSiteDatasetCategoryOf}, AGL-3856); absent for a list that files none. */
+    categories?: ReadonlyArray<string | null>;
     pictures: AiSiteDatasetPictures;
     signal?: AbortSignal;
     stockPhotos?: typeof aiLayoutStockPhotoSource;
@@ -195,6 +198,23 @@ export interface AiSiteDatasetRunnerDeps {
     /** Where a pictured dataset's photos come from; the stock library, else the starters, otherwise. */
     photos?: typeof aiSiteDatasetRecordPhotos;
 }
+/**
+ * What a designed dataset's records are filed under (AGL-3921): its first
+ * field whose name says it files them ("Category", "Type", "Session type"),
+ * with each record's value, where they hold at least two different values
+ * and some record shares one — a list that files every record apart files
+ * none. `null` otherwise. Pure.
+ */
+export declare function aiSiteDatasetCategoryOf(dataset: {
+    fields: ReadonlyArray<{
+        name: string;
+    }>;
+    records: ReadonlyArray<ReadonlyArray<string | undefined>>;
+}): {
+    column: number;
+    name: string;
+    values: Array<string | null>;
+} | null;
 /**
  * The fields of a designed dataset that its records leave empty on most of
  * them — every record, or more than half — by the id the data plugin gave
@@ -249,6 +269,11 @@ export declare function aiDatasetListingsOf(datasets: ReadonlyArray<{
     imageField?: string | null;
     /** The record's page-address field, where the writer added one (AGL-3727). */
     addressField?: string | null;
+    /** What its records are filed under, by position as `records` (AGL-3921): a section named for one value lists its records alone. */
+    groups?: {
+        field: string;
+        values: readonly string[];
+    } | null;
 }>, screens: readonly AiLayoutListingScreen[]): AiLayoutListing[];
 /**
  * A `records` listing for each dataset the workspace already keeps that a
@@ -267,6 +292,62 @@ export declare function aiSiteReusedDatasetListings(input: {
     /** The listings the start already has, whose datasets are not listed twice. */
     listed: ReadonlyArray<Pick<AiLayoutListing, 'datasetId'>>;
 }): AiLayoutListing[];
+/**
+ * A SITE START NEVER SHOWS ANOTHER SITE'S RECORDS (AGL-3912).
+ *
+ * Datasets belong to the organization, and so do their records: neither
+ * names the site it was written for, and a dataset outlives the site that
+ * filled it (the data plugin keeps `visibleTo` and nothing else of a site). A
+ * gym's start reused the workspace's "Session packages", "Coaches" and "Gym
+ * FAQs", and published a deleted photographer's wedding packages and a
+ * deleted studio's coach bio ("Leads coaching at Ironline Strength Studio")
+ * with four broken photos; a photographer's start reused another
+ * photographer's gallery and drew six broken covers.
+ *
+ * So a site start reuses a dataset only when its records are this site's to
+ * show ({@link aiSiteDatasetIsThisSites}):
+ *  - it holds no records at all — an empty list, such as the one a form
+ *    writes its submissions to, is the same list on any site; or
+ *  - its scope names this site alone (`siteOnly`), so it was made for it; or
+ *  - this site already serves its records pages of their own (`recordBase`).
+ * Anything else — records in a dataset shared with the workspace or with
+ * other sites, and a dataset whose records could not be counted — was filled
+ * for something else, and the plan is settled in code before the rules read
+ * it ({@link aiSettleSiteForeignDatasets}): the reuse becomes a creation of
+ * the same name and fields, designed from this site's brief with photos of
+ * its own, and every section, record template and form that named it names
+ * the creation. Where this job may create no dataset, the reuse comes off
+ * instead and each section writes its items out. Never a refusal, and
+ * nothing a member is asked.
+ *
+ * An Assist change to a site that exists keeps reusing what the site lists:
+ * this is a site start's rule, and only its plan is settled by it.
+ */
+export declare function aiSiteDatasetIsThisSites(row: Pick<AiInventoryDataset, 'records' | 'siteOnly' | 'recordBase'>): boolean;
+/**
+ * A site start's plan with every dataset it reuses that holds another
+ * site's records made again for this one (AGL-3912): each the inventory marks
+ * `foreign` ({@link aiSiteInventoryWithRecordCounts}, by
+ * {@link aiSiteDatasetIsThisSites}). The creation keeps the dataset's name,
+ * which rule 7 does not hold against it as a duplicate. Pure; a plan that
+ * reuses none comes back as it was.
+ */
+export declare function aiSettleSiteForeignDatasets(plan: AiBuildPlan, inventory: Pick<AiSiteInventory, 'datasets'> | null, capabilities?: AiPlanCapabilities | null): AiBuildPlan;
+/** How a dataset's records are counted: the data plugin's index, which answers `facts.records`. */
+export type AiDatasetRecordCounter = (request: {
+    orgId: string;
+    id: string;
+}) => Promise<number | null>;
+/** The production counter: the data plugin's `dataset` index, read one dataset at a time. */
+export declare const aiDatasetRecordCount: AiDatasetRecordCounter;
+/**
+ * A site start's inventory with how many records each dataset holds
+ * (AGL-3912), and each whose records are not this site's to show
+ * ({@link aiSiteDatasetIsThisSites}) marked `foreign`. The count is asked
+ * once per plan, of every dataset the site sees, all at once; a count that
+ * fails leaves `records` out, which reads as another site's. Never throws.
+ */
+export declare function aiSiteInventoryWithRecordCounts(inventory: AiSiteInventory | null, orgId: string, count?: AiDatasetRecordCounter): Promise<AiSiteInventory | null>;
 /**
  * The site's datasets a layout or a page unit is handed (AGL-3616), each a
  * `records` listing with the sections of the plan's pages that name it, once

package/src/lib/jobs/ai-job-site-datasets.js

@@ -16,7 +16,9 @@ import { _ as _extends } from "@swc/helpers/_/_extends";
  * limitations under the License.
  */ import { checkDatasetQuota } from "@aglyn/aglyn/app-utils/plan-entitlements";
 import { pluginResourceDraftWriter } from "@aglyn/aglyn/plugin-manager/plugin-resource-drafts";
-import { isAiPlanNewRef } from "../model/ai-build-plan.js";
+import { pluginRecordIndex } from "@aglyn/aglyn/plugin-manager/plugin-record-index";
+import { AI_BUILD_PLAN_LIMITS, AI_PLAN_NEW_REF_PREFIX, isAiPlanNewRef } from "../model/ai-build-plan.js";
+import { AI_TYPED_LIST_MIN_ITEMS } from "../runtime/ai-doctrine-validators.js";
 import { AI_SITE_DATASETS_MAX } from "../model/ai-site-job.js";
 import { AI_STEP_TIERS } from "../providers/catalog.js";
 import { aiModelForStep } from "../providers/routing.js";
@@ -242,7 +244,9 @@ const limitReview = (message)=>({
             placed: null
         }));
     const people = input.pictures === 'people';
-    const slots = input.names.map((name, index)=>({
+    const slots = input.names.map((name, index)=>{
+        var _input_categories_index, _input_categories;
+        return _extends({
             imageId: `record${index}`,
             frameId: null,
             iconId: null,
@@ -253,7 +257,14 @@ const limitReview = (message)=>({
             role: people ? 'about' : 'gallery',
             // A record's name is a search's words, never what its photo shows (AGL-3856).
             standIn: true
-        }));
+        }, people ? {
+            people: true
+        } : {}, people ? {} : {
+            record: ((_input_categories = input.categories) == null ? void 0 : (_input_categories_index = _input_categories[index]) == null ? void 0 : _input_categories_index.trim()) ? {
+                category: input.categories[index].trim()
+            } : {}
+        });
+    });
     const seed = `${job.$id}:records`;
     let found = [];
     try {
@@ -343,6 +354,51 @@ const limitReview = (message)=>({
         })
     });
 }
+/** A field whose name says it files its records: a category, a type, a kind. */ const CATEGORY_FIELD = /^(?:(?:gallery|session|service|event|course|class|product|menu|work|project) )?(?:category|categories|type|kind|collection|genre|group|section|subject|occasion|series)$/i;
+/**
+ * What a designed dataset's records are filed under (AGL-3921): its first
+ * field whose name says it files them ("Category", "Type", "Session type"),
+ * with each record's value, where they hold at least two different values
+ * and some record shares one — a list that files every record apart files
+ * none. `null` otherwise. Pure.
+ */ export function aiSiteDatasetCategoryOf(dataset) {
+    for (const [column, field] of dataset.fields.entries()){
+        if (column === 0 || !CATEGORY_FIELD.test(field.name.trim())) continue;
+        const values = dataset.records.map((values)=>{
+            var _values_column;
+            return ((_values_column = values[column]) != null ? _values_column : '').replace(/\s+/g, ' ').trim() || null;
+        });
+        const distinct = new Set(values.filter((value)=>Boolean(value)).map((value)=>value.toLowerCase()));
+        if (distinct.size >= 2 && distinct.size < values.filter(Boolean).length) return {
+            column,
+            name: field.name,
+            values
+        };
+    }
+    return null;
+}
+/**
+ * A dataset's groups as its proposal keeps them: the written field's id, and
+ * the value of each record its {@link AiSiteDatasetProposal.recordNames} names.
+ */ function aiSiteDatasetGroupsOf(category, written, designed) {
+    var _ref;
+    var _written_find, _written_category_column;
+    if (!category) return {};
+    const field = (_ref = (_written_find = written.find((entry)=>entry.name.trim().toLowerCase() === category.name.trim().toLowerCase())) == null ? void 0 : _written_find.id) != null ? _ref : written.length === designed.fields.length ? (_written_category_column = written[category.column]) == null ? void 0 : _written_category_column.id : undefined;
+    if (!field) return {};
+    const values = designed.records.flatMap((record, index)=>{
+        var _category_values_index;
+        return record[0] ? [
+            (_category_values_index = category.values[index]) != null ? _category_values_index : ''
+        ] : [];
+    }).slice(0, 12);
+    return {
+        groups: {
+            field,
+            values
+        }
+    };
+}
 /**
  * The fields of a designed dataset that its records leave empty on most of
  * them — every record, or more than half — by the id the data plugin gave
@@ -371,7 +427,7 @@ const limitReview = (message)=>({
 function proposalOf(output) {
     var _output_proposal;
     const raw = (_output_proposal = output.proposal) != null ? _output_proposal : {};
-    return {
+    return _extends({
         fields: Array.isArray(raw.fields) ? raw.fields.filter((field)=>field && typeof field.id === 'string' && field.id).map((field)=>({
                 id: field.id,
                 name: str(field.name) || field.id,
@@ -382,7 +438,12 @@ function proposalOf(output) {
         imageField: str(raw.imageField) || null,
         photos: Array.isArray(raw.photos) ? raw.photos.map(str).filter((src)=>src.startsWith('media:')).slice(0, 24) : [],
         sparseFields: Array.isArray(raw.sparseFields) ? raw.sparseFields.map(str).filter(Boolean) : []
-    };
+    }, raw.groups && typeof raw.groups === 'object' && str(raw.groups.field) && Array.isArray(raw.groups.values) ? {
+        groups: {
+            field: str(raw.groups.field),
+            values: raw.groups.values.slice(0, 12).map(str)
+        }
+    } : {});
 }
 /**
  * The dataset unit's runner, on the job the scaffold derived for it: the one
@@ -395,7 +456,7 @@ function proposalOf(output) {
     const writerFor = (_deps_writerFor = deps.writerFor) != null ? _deps_writerFor : pluginResourceDraftWriter;
     const photosFor = (_deps_photos = deps.photos) != null ? _deps_photos : aiSiteDatasetRecordPhotos;
     return async (context)=>{
-        var _ref, _context_org, _facts_fields, _facts_addressField, _facts_fields1, _facts_records;
+        var _ref, _context_org, _facts_fields, _facts_addressField, _facts_fields1, _facts_fields2, _facts_records;
         var _job_plan_create, _job_plan;
         const { job, firestore, signal } = context;
         const model = (_ref = context.modelFor == null ? void 0 : context.modelFor.call(context, AI_DATASET_STEP)) != null ? _ref : aiModelForStep(AI_DATASET_STEP);
@@ -429,10 +490,10 @@ function proposalOf(output) {
             id: job.$id
         });
         if (written) {
-            var _facts_fields2, _facts_addressField1, _facts_imageField;
+            var _facts_fields3, _facts_addressField1, _facts_imageField;
             const facts = written.facts;
             const again = output(written.id, written.name || creation.name, {
-                fields: (_facts_fields2 = facts.fields) != null ? _facts_fields2 : [],
+                fields: (_facts_fields3 = facts.fields) != null ? _facts_fields3 : [],
                 recordNames: [],
                 addressField: (_facts_addressField1 = facts.addressField) != null ? _facts_addressField1 : null,
                 imageField: (_facts_imageField = facts.imageField) != null ? _facts_imageField : null
@@ -448,7 +509,7 @@ function proposalOf(output) {
         // A form's dataset (AGL-3616): its records are the submissions, so it is
         // designed from the plan with no model, and starts empty.
         if (input.forForm) {
-            var _context_org1, _facts_fields3;
+            var _context_org1, _facts_fields4;
             const content = aiSiteFormDatasetContent(creation.name, creation.fields, input.forForm);
             const checked = keeper.writer.check(content, {
                 hostId: job.hostId
@@ -485,7 +546,7 @@ function proposalOf(output) {
             return aiUnspentOutcome(model, {
                 outputs: [
                     _extends({}, output(result.id, result.name, {
-                        fields: (_facts_fields3 = facts.fields) != null ? _facts_fields3 : [],
+                        fields: (_facts_fields4 = facts.fields) != null ? _facts_fields4 : [],
                         recordNames: [],
                         addressField: null
                     }, 0), {
@@ -517,6 +578,8 @@ function proposalOf(output) {
         const designed = aiDatasetDraftContent(creation.name, generation.value, {
             recordPages: input.recordPages
         });
+        // What each record is filed under, which its photo and the sections that list it by its value read (AGL-3856).
+        const category = aiSiteDatasetCategoryOf(generation.value);
         // A list a visitor looks at keeps its records' photos (AGL-3616): searched
         // in code, never asked of the model, so they cost no credits.
         const photos = input.pictures ? await photosFor(_extends({
@@ -525,7 +588,10 @@ function proposalOf(output) {
             names: generation.value.records.map((values)=>{
                 var _values_;
                 return (_values_ = values[0]) != null ? _values_ : '';
-            }),
+            })
+        }, category ? {
+            categories: category.values
+        } : {}, {
             pictures: input.pictures
         }, signal ? {
             signal
@@ -590,7 +656,7 @@ function proposalOf(output) {
             photos: placed
         } : {}, {
             sparseFields: aiDatasetSparseFields(generation.value, (_facts_fields1 = facts.fields) != null ? _facts_fields1 : [])
-        });
+        }, aiSiteDatasetGroupsOf(category, (_facts_fields2 = facts.fields) != null ? _facts_fields2 : [], generation.value));
         return _extends({}, spent, {
             outputs: [
                 output(result.id, result.name, proposal, (_facts_records = facts.records) != null ? _facts_records : generation.value.records.length)
@@ -727,6 +793,201 @@ export const runAiSiteDatasetUnit = createAiSiteDatasetRunner();
     });
     return aiDatasetListingsOf(datasets, input.screens);
 }
+/**
+ * A SITE START NEVER SHOWS ANOTHER SITE'S RECORDS (AGL-3912).
+ *
+ * Datasets belong to the organization, and so do their records: neither
+ * names the site it was written for, and a dataset outlives the site that
+ * filled it (the data plugin keeps `visibleTo` and nothing else of a site). A
+ * gym's start reused the workspace's "Session packages", "Coaches" and "Gym
+ * FAQs", and published a deleted photographer's wedding packages and a
+ * deleted studio's coach bio ("Leads coaching at Ironline Strength Studio")
+ * with four broken photos; a photographer's start reused another
+ * photographer's gallery and drew six broken covers.
+ *
+ * So a site start reuses a dataset only when its records are this site's to
+ * show ({@link aiSiteDatasetIsThisSites}):
+ *  - it holds no records at all — an empty list, such as the one a form
+ *    writes its submissions to, is the same list on any site; or
+ *  - its scope names this site alone (`siteOnly`), so it was made for it; or
+ *  - this site already serves its records pages of their own (`recordBase`).
+ * Anything else — records in a dataset shared with the workspace or with
+ * other sites, and a dataset whose records could not be counted — was filled
+ * for something else, and the plan is settled in code before the rules read
+ * it ({@link aiSettleSiteForeignDatasets}): the reuse becomes a creation of
+ * the same name and fields, designed from this site's brief with photos of
+ * its own, and every section, record template and form that named it names
+ * the creation. Where this job may create no dataset, the reuse comes off
+ * instead and each section writes its items out. Never a refusal, and
+ * nothing a member is asked.
+ *
+ * An Assist change to a site that exists keeps reusing what the site lists:
+ * this is a site start's rule, and only its plan is settled by it.
+ */ export function aiSiteDatasetIsThisSites(row) {
+    return row.records === 0 || row.siteOnly === true || Boolean(row.recordBase);
+}
+/** A planned field that is a record's page address, which the writer adds itself. */ const ADDRESS_FIELD_NAME = /^(?:page )?(?:address|slug|url|link)$/i;
+/** The fields a dataset is made again with: its own, less the photo, its description and the page address the writer adds. */ function remadeFields(row) {
+    var _row_fieldIds;
+    const ids = (_row_fieldIds = row.fieldIds) != null ? _row_fieldIds : [];
+    return row.fields.filter((name, index)=>{
+        const id = ids[index];
+        if (id && (id === row.imageField || id === row.addressField)) return false;
+        if (IMAGE_FIELD_NAME.test(name.trim()) || ADDRESS_FIELD_NAME.test(name.trim())) return false;
+        return name.trim().toLowerCase() !== AI_SITE_DATASET_IMAGE_ALT_FIELD.toLowerCase();
+    }).slice(0, AI_BUILD_PLAN_LIMITS.fields);
+}
+/**
+ * A site start's plan with every dataset it reuses that holds another
+ * site's records made again for this one (AGL-3912): each the inventory marks
+ * `foreign` ({@link aiSiteInventoryWithRecordCounts}, by
+ * {@link aiSiteDatasetIsThisSites}). The creation keeps the dataset's name,
+ * which rule 7 does not hold against it as a duplicate. Pure; a plan that
+ * reuses none comes back as it was.
+ */ export function aiSettleSiteForeignDatasets(plan, inventory, capabilities = null) {
+    var _ref, _plan_items;
+    const rows = new Map(((_ref = inventory == null ? void 0 : inventory.datasets) != null ? _ref : []).map((row)=>[
+            row.id,
+            row
+        ]));
+    const foreign = plan.reuse.filter((entry)=>{
+        var _rows_get;
+        return entry.kind === 'dataset' && ((_rows_get = rows.get(entry.id)) == null ? void 0 : _rows_get.foreign) === true;
+    });
+    if (!foreign.length) return plan;
+    const creatable = !capabilities || capabilities.create.dataset.allowed;
+    const taken = new Map([
+        ...plan.create.map((entry)=>[
+                entry.name.trim().toLowerCase(),
+                entry
+            ]),
+        ...((_plan_items = plan.items) != null ? _plan_items : []).map((item)=>[
+                item.name.trim().toLowerCase(),
+                null
+            ])
+    ]);
+    // Each foreign dataset's id → the `new:` reference that replaces it, or `null` where it comes off.
+    const replaced = new Map();
+    const added = [];
+    for (const entry of foreign){
+        const row = rows.get(entry.id);
+        const base = row.name.trim() || 'Records';
+        if (!creatable) {
+            replaced.set(entry.id, null);
+            continue;
+        }
+        // The plan already makes one of that name: that one is this site's.
+        const same = taken.get(base.toLowerCase());
+        if ((same == null ? void 0 : same.kind) === 'dataset') {
+            replaced.set(entry.id, `${AI_PLAN_NEW_REF_PREFIX}${same.name}`);
+            continue;
+        }
+        let name = base;
+        for(let n = 2; taken.has(name.toLowerCase()); n += 1)name = `${base} ${n}`;
+        const creation = {
+            kind: 'dataset',
+            name,
+            why: entry.purpose || `Lists ${base} on this site.`,
+            duplicateOf: null,
+            fields: remadeFields(row)
+        };
+        added.push(creation);
+        taken.set(name.toLowerCase(), creation);
+        replaced.set(entry.id, `${AI_PLAN_NEW_REF_PREFIX}${name}`);
+    }
+    const swap = (ref)=>{
+        var _replaced_get;
+        return replaced.has(ref) ? (_replaced_get = replaced.get(ref)) != null ? _replaced_get : null : ref;
+    };
+    return _extends({}, plan, {
+        reuse: plan.reuse.filter((entry)=>!(entry.kind === 'dataset' && replaced.has(entry.id))),
+        create: [
+            ...plan.create.map((entry)=>{
+                if (entry.kind !== 'form' || !entry.writesTo || !replaced.has(entry.writesTo)) return entry;
+                const writesTo = swap(entry.writesTo);
+                if (writesTo) return _extends({}, entry, {
+                    writesTo
+                });
+                // A form whose dataset comes off sends its submissions to the Inbox only.
+                const rest = _extends({}, entry);
+                delete rest.writesTo;
+                return rest;
+            }),
+            ...added
+        ],
+        screens: plan.screens.map((screen)=>{
+            // A record template of a dataset made again shows the new one; of one that comes off, it is a page of its own.
+            const record = screen.record && replaced.has(screen.record.dataset) ? {
+                record: swap(screen.record.dataset)
+            } : null;
+            const sections = screen.sections.map((section)=>{
+                if (!section.uses.some((ref)=>replaced.has(ref))) return section;
+                const uses = section.uses.flatMap((ref)=>{
+                    const next = swap(ref);
+                    return next ? [
+                        next
+                    ] : [];
+                });
+                // A list that comes off is written out on the page, as fewer items than a dataset binds.
+                const dropped = section.uses.some((ref)=>replaced.has(ref) && !replaced.get(ref));
+                return _extends({}, section, {
+                    uses
+                }, dropped ? {
+                    items: Math.min(section.items, AI_TYPED_LIST_MIN_ITEMS - 1)
+                } : {});
+            });
+            return _extends({}, screen, record && screen.record ? {
+                record: record.record ? _extends({}, screen.record, {
+                    dataset: record.record
+                }) : null
+            } : {}, {
+                sections
+            });
+        })
+    });
+}
+/** The production counter: the data plugin's `dataset` index, read one dataset at a time. */ export const aiDatasetRecordCount = async ({ orgId, id })=>{
+    var _pluginRecordIndex;
+    const index = (_pluginRecordIndex = pluginRecordIndex('dataset')) == null ? void 0 : _pluginRecordIndex.index;
+    if (!index) return null;
+    const found = await index.get({
+        orgId,
+        id
+    });
+    const records = found == null ? void 0 : found.facts['records'];
+    return typeof records === 'number' && Number.isFinite(records) ? records : null;
+};
+/**
+ * A site start's inventory with how many records each dataset holds
+ * (AGL-3912), and each whose records are not this site's to show
+ * ({@link aiSiteDatasetIsThisSites}) marked `foreign`. The count is asked
+ * once per plan, of every dataset the site sees, all at once; a count that
+ * fails leaves `records` out, which reads as another site's. Never throws.
+ */ export async function aiSiteInventoryWithRecordCounts(inventory, orgId, count = aiDatasetRecordCount) {
+    if (!(inventory == null ? void 0 : inventory.datasets.length)) return inventory;
+    const counts = await Promise.all(inventory.datasets.map((row)=>count({
+            orgId,
+            id: row.id
+        }).catch((error)=>{
+            console.warn('ai site plan: a dataset’s records could not be counted', {
+                orgId,
+                id: row.id,
+                error: String(error)
+            });
+            return null;
+        })));
+    return _extends({}, inventory, {
+        datasets: inventory.datasets.map((row, index)=>{
+            const records = counts[index];
+            const counted = typeof records === 'number' ? _extends({}, row, {
+                records
+            }) : row;
+            return aiSiteDatasetIsThisSites(counted) ? counted : _extends({}, counted, {
+                foreign: true
+            });
+        })
+    });
+}
 /**
  * The site's datasets a layout or a page unit is handed (AGL-3616), each a
  * `records` listing with the sections of the plan's pages that name it, once
@@ -734,7 +995,7 @@ export const runAiSiteDatasetUnit = createAiSiteDatasetRunner();
  * nowhere: the pages built without it write the items out.
  */ export function aiSiteDatasetListings(input) {
     const made = input.datasets.flatMap((dataset)=>{
-        var _proposal_imageField;
+        var _proposal_imageField, _proposal_groups;
         const id = input.delivered.get(dataset.name.trim().toLowerCase());
         const output = id ? input.outputs.find((entry)=>entry.resource === 'draft' && entry.draftResource === AI_SITE_DATASET_RESOURCE && entry.id === id) : undefined;
         if (!id || !output) return [];
@@ -753,7 +1014,8 @@ export const runAiSiteDatasetUnit = createAiSiteDatasetRunner();
                     return field.id !== proposal.addressField && field.id !== proposal.imageField && (index === 0 || !((_proposal_sparseFields = proposal.sparseFields) == null ? void 0 : _proposal_sparseFields.includes(field.id)));
                 }),
                 imageField: (_proposal_imageField = proposal.imageField) != null ? _proposal_imageField : null,
-                addressField: proposal.addressField
+                addressField: proposal.addressField,
+                groups: (_proposal_groups = proposal.groups) != null ? _proposal_groups : null
             }
         ];
     });