@researchdatabox/redbox-core 0.0.1-beta.10213 → 0.0.1-beta.10760

package/dist/services/FigshareVocabularyService.js

@@ -0,0 +1,1802 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Services = void 0;
+const CoreService_1 = require("../CoreService");
+const FigshareVocabularySyncRun_1 = require("../waterline-models/FigshareVocabularySyncRun");
+const TransactionUtils_1 = require("../utilities/TransactionUtils");
+const PromiseUtils_1 = require("../utilities/PromiseUtils");
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const lodash_1 = __importDefault(require("lodash"));
+const config_1 = require("./figshare-v2/config");
+const http_1 = require("./figshare-v2/http");
+const categories_1 = require("./figshare-v2/categories");
+const vocabulary_errors_1 = require("./figshare-v2/vocabulary-errors");
+var Services;
+(function (Services) {
+    const PREVIEW_TTL_MS = 24 * 60 * 60 * 1000;
+    const MAX_MAPPING_BATCH = 2000;
+    const MAX_PAGE_SIZE = 200;
+    const DEFAULT_BOOTSTRAP_DATA_PATH = 'bootstrap-data';
+    const FIGSHARE_IMPORTS_FILE = 'figshare-imports.json';
+    const FIGSHARE_IMPORT_TIMEOUT_MS = 120_000;
+    const BOOTSTRAP_ACTOR = 'bootstrap-data';
+    class FigshareVocabularyService extends CoreService_1.Services.Core.Service {
+        _exportedMethods = [
+            'discoverTaxonomies',
+            'createPreview',
+            'getPreview',
+            'applyPreview',
+            'cloneMirror',
+            'listSources',
+            'getSource',
+            'listSourceCategories',
+            'listSyncRuns',
+            'listCrosswalks',
+            'getCrosswalk',
+            'getCrosswalkUsage',
+            'createCrosswalk',
+            'listCrosswalkLocalEntries',
+            'listCrosswalkMappings',
+            'saveMappings',
+            'approveCrosswalk',
+            'deleteCrosswalk',
+            'resolveCategories',
+            'resolveCrosswalkValues',
+            'bootstrapData'
+        ];
+        // ── Infrastructure helpers ────────────────────────────────────────
+        getDatastore() {
+            return Vocabulary.getDatastore?.() ?? sails.getDatastore?.() ?? null;
+        }
+        async runQuery(query, connection) {
+            return connection ? query.usingConnection(connection) : query;
+        }
+        async createOne(query, connection) {
+            return this.runQuery(query.fetch(), connection);
+        }
+        nowIso() {
+            return new Date().toISOString();
+        }
+        resolveBrandName(brandId) {
+            const brandingService = typeof BrandingService === 'undefined' ? undefined : BrandingService;
+            const brand = brandingService?.getBrandById?.(brandId);
+            if (brand?.name != null && String(brand.name).trim() !== '') {
+                return String(brand.name);
+            }
+            return String(brandId);
+        }
+        buildRunContext(brandId, correlationId) {
+            const brandName = this.resolveBrandName(brandId);
+            return {
+                recordOid: '',
+                brandId,
+                brandName,
+                correlationId,
+                triggerSource: 'figshare-vocabulary-admin'
+            };
+        }
+        /**
+         * Resolve a Figshare client for catalogue reads. The client is always built from
+         * trusted deployment configuration; a request never supplies a base URL or token.
+         */
+        resolveClient(brandId, scope) {
+            const brandName = this.resolveBrandName(brandId);
+            const config = (0, config_1.resolveFigshareVocabularyConfig)(brandName);
+            if (config == null) {
+                throw new vocabulary_errors_1.FigshareTransportError('Figshare is not configured for this brand');
+            }
+            if (scope === 'account' && String(config.connection.token ?? '').trim() === '' && config.runtime.mode !== 'fixture') {
+                throw new vocabulary_errors_1.FigshareTransportError('The Figshare account catalogue requires a configured API token', 401);
+            }
+            const runContext = this.buildRunContext(brandId, `figshare-vocab-${Date.now()}`);
+            return config.runtime.mode === 'fixture'
+                ? (0, http_1.makeFixtureClient)(config)
+                : (0, http_1.makeLiveClient)(config, runContext);
+        }
+        async fetchCatalogue(brandId, scope) {
+            const client = this.resolveClient(brandId, scope);
+            try {
+                return scope === 'account' ? await client.listAccountCategories() : await client.listPublicCategories();
+            }
+            catch (error) {
+                if (error instanceof http_1.FigshareHttpError) {
+                    // FigshareHttpError already strips the axios request config; keep it that way.
+                    throw new vocabulary_errors_1.FigshareTransportError(`Figshare category catalogue request failed${error.statusCode == null ? '' : ` (status ${error.statusCode})`}`, error.statusCode);
+                }
+                throw error;
+            }
+        }
+        assertScope(scope) {
+            const normalized = String(scope ?? '').trim().toLowerCase();
+            if (normalized !== 'public' && normalized !== 'account') {
+                throw new vocabulary_errors_1.CatalogueInvalidError("scope must be either 'public' or 'account'");
+            }
+            return normalized;
+        }
+        parsePaging(limit, offset, defaultLimit = 50) {
+            const parsedLimit = Number.parseInt(String(limit ?? defaultLimit), 10);
+            const parsedOffset = Number.parseInt(String(offset ?? 0), 10);
+            return {
+                limit: Number.isInteger(parsedLimit) && parsedLimit > 0 ? Math.min(MAX_PAGE_SIZE, parsedLimit) : defaultLimit,
+                offset: Number.isInteger(parsedOffset) && parsedOffset >= 0 ? parsedOffset : 0
+            };
+        }
+        // ── Brand-scoped resolution ───────────────────────────────────────
+        async requireSource(sourceId, brandId) {
+            const source = await FigshareVocabularySource.findOne({
+                id: String(sourceId ?? '').trim(),
+                branding: brandId
+            });
+            if (!source) {
+                throw new vocabulary_errors_1.RelationshipBoundaryError('Figshare source not found');
+            }
+            return source;
+        }
+        async requireCrosswalk(crosswalkId, brandId) {
+            const crosswalk = await FigshareVocabularyCrosswalk.findOne({
+                id: String(crosswalkId ?? '').trim(),
+                branding: brandId
+            });
+            if (!crosswalk) {
+                throw new vocabulary_errors_1.RelationshipBoundaryError('Figshare crosswalk not found');
+            }
+            return crosswalk;
+        }
+        async requireLocalVocabulary(vocabularyId, brandId) {
+            const vocabulary = await Vocabulary.findOne({
+                id: String(vocabularyId ?? '').trim(),
+                branding: brandId
+            });
+            if (!vocabulary) {
+                throw new vocabulary_errors_1.RelationshipBoundaryError('Local vocabulary not found');
+            }
+            if (vocabulary.source === 'external') {
+                throw new vocabulary_errors_1.RelationshipBoundaryError('A Figshare mirror cannot be used as the local side of a crosswalk');
+            }
+            return vocabulary;
+        }
+        async requireRun(runId, brandId) {
+            const run = await FigshareVocabularySyncRun.findOne({
+                id: String(runId ?? '').trim(),
+                branding: brandId
+            });
+            if (!run) {
+                throw new vocabulary_errors_1.RelationshipBoundaryError('Synchronisation preview not found');
+            }
+            return run;
+        }
+        /** Expiry is enforced synchronously; no scheduled job is introduced. */
+        async pruneExpiredRuns(brandId) {
+            const now = this.nowIso();
+            await FigshareVocabularySyncRun.update({
+                branding: brandId,
+                state: ['fetching', 'previewed'],
+                expiresAt: { '<': now }
+            }).set({ state: 'expired' });
+        }
+        async transitionRun(runId, from, to, patch = {}, connection) {
+            if (!(0, FigshareVocabularySyncRun_1.isAllowedSyncRunTransition)(from, to)) {
+                throw new vocabulary_errors_1.StalePreviewError(`Synchronisation run cannot move from '${from}' to '${to}'`);
+            }
+            const updated = await this.runQuery(FigshareVocabularySyncRun.updateOne({ id: runId, state: from }).set({ ...patch, state: to }), connection);
+            if (!updated) {
+                throw new vocabulary_errors_1.StalePreviewError(`Synchronisation run is no longer '${from}'`);
+            }
+        }
+        // ── Discovery ─────────────────────────────────────────────────────
+        async discoverTaxonomies(input, ctx) {
+            const scope = this.assertScope(input?.scope);
+            const raw = await this.fetchCatalogue(ctx.brandId, scope);
+            return (0, categories_1.groupTaxonomies)((0, categories_1.normalizeFigshareCategories)(raw));
+        }
+        // ── Preview ───────────────────────────────────────────────────────
+        async loadSnapshot(brandId, scope, taxonomyId) {
+            const raw = await this.fetchCatalogue(brandId, scope);
+            const normalized = (0, categories_1.normalizeFigshareCategories)(raw);
+            const filtered = (0, categories_1.filterByTaxonomy)(normalized, taxonomyId);
+            if (filtered.rows.length === 0) {
+                throw new vocabulary_errors_1.CatalogueInvalidError(`Figshare returned no categories for taxonomy '${taxonomyId}'`);
+            }
+            (0, categories_1.assertSnapshotWithinLimits)(filtered.rows);
+            return { rows: filtered.rows, warnings: filtered.warnings };
+        }
+        async loadExistingCategories(sourceId) {
+            const categories = await FigshareVocabularyCategory.find({ source: sourceId });
+            return categories.map((category) => ({
+                sourceId: category.sourceId,
+                categoryId: category.categoryId,
+                title: '',
+                contentHash: category.contentHash,
+                historical: category.historical === true
+            }));
+        }
+        async loadLocalEntries(vocabularyId) {
+            const entries = await VocabularyEntry.find({ vocabulary: vocabularyId });
+            return entries.map((entry) => ({
+                id: String(entry.id),
+                label: String(entry.label ?? ''),
+                labelLower: String(entry.labelLower ?? ''),
+                value: String(entry.value ?? ''),
+                valueLower: String(entry.valueLower ?? ''),
+                identifier: entry.identifier
+            }));
+        }
+        /**
+         * A brand may only mirror a given catalogue once, so an import that names no explicit
+         * source still has to bind the existing mirror instead of creating a second one.
+         */
+        async findSourceForCatalogue(brandId, scope, taxonomyId) {
+            return await FigshareVocabularySource.findOne({
+                branding: brandId,
+                scope,
+                taxonomyId
+            });
+        }
+        /**
+         * Likewise, a local vocabulary is crosswalked to a mirror at most once; re-running the
+         * wizard for an existing pairing resynchronises that crosswalk rather than forking it.
+         */
+        async findCrosswalkForPairing(brandId, localVocabularyId, sourceId) {
+            return await FigshareVocabularyCrosswalk.findOne({
+                branding: brandId,
+                localVocabulary: localVocabularyId,
+                figshareSource: sourceId
+            });
+        }
+        /**
+         * Resolve which of the mutually exclusive preview modes was requested.
+         *
+         * Four shapes are accepted: an explicit crosswalk resync, a mirror-only resync
+         * (`sourceId` with no local target), an existing local vocabulary, and a new clone.
+         */
+        async resolvePreviewMode(input, brandId, scope) {
+            const createLocalClone = input.createLocalClone === true;
+            const normalizedScope = scope ?? this.assertScope(input?.scope);
+            const crosswalkId = String(input.crosswalkId ?? '').trim();
+            const sourceId = String(input.sourceId ?? '').trim();
+            const localVocabularyId = String(input.localVocabularyId ?? '').trim();
+            if (crosswalkId) {
+                if (localVocabularyId || createLocalClone) {
+                    throw new vocabulary_errors_1.CatalogueInvalidError('A crosswalk resync cannot also select a local vocabulary or request a clone');
+                }
+                const crosswalk = await this.requireCrosswalk(crosswalkId, brandId);
+                const source = await this.requireSource(String(crosswalk.figshareSource), brandId);
+                const localVocabulary = await this.requireLocalVocabulary(String(crosswalk.localVocabulary), brandId);
+                return { source, crosswalk, localVocabulary, createLocalClone: false };
+            }
+            if (localVocabularyId && createLocalClone) {
+                throw new vocabulary_errors_1.CatalogueInvalidError('Select an existing local vocabulary or create a clone, not both');
+            }
+            if (createLocalClone && String(input.localCloneName ?? '').trim() === '') {
+                throw new vocabulary_errors_1.CatalogueInvalidError('localCloneName is required when creating an editable clone');
+            }
+            const source = sourceId
+                ? await this.requireSource(sourceId, brandId)
+                : await this.findSourceForCatalogue(brandId, normalizedScope, String(input.taxonomyId ?? '').trim());
+            // Refreshing an existing mirror is a complete request on its own; only a brand new
+            // mirror needs to be told what it should be crosswalked to.
+            if (!localVocabularyId && !createLocalClone && !source) {
+                throw new vocabulary_errors_1.CatalogueInvalidError('Select an existing local vocabulary or request an editable clone');
+            }
+            const localVocabulary = localVocabularyId ? await this.requireLocalVocabulary(localVocabularyId, brandId) : null;
+            const crosswalk = source && localVocabulary
+                ? await this.findCrosswalkForPairing(brandId, String(localVocabulary.id), String(source.id))
+                : null;
+            return { source, crosswalk, localVocabulary, createLocalClone };
+        }
+        async createPreview(input, ctx) {
+            await this.pruneExpiredRuns(ctx.brandId);
+            const scope = this.assertScope(input?.scope);
+            const taxonomyId = String(input?.taxonomyId ?? '').trim();
+            if (!taxonomyId) {
+                throw new vocabulary_errors_1.CatalogueInvalidError('taxonomyId is required');
+            }
+            const mode = await this.resolvePreviewMode(input, ctx.brandId, scope);
+            if (mode.source && mode.source.scope !== scope) {
+                throw new vocabulary_errors_1.CatalogueInvalidError('The requested scope does not match the existing Figshare source');
+            }
+            if (mode.source && mode.source.taxonomyId !== taxonomyId) {
+                throw new vocabulary_errors_1.CatalogueInvalidError('The requested taxonomy does not match the existing Figshare source');
+            }
+            const snapshot = await this.loadSnapshot(ctx.brandId, scope, taxonomyId);
+            const remoteHash = (0, categories_1.hashSnapshot)(snapshot.rows);
+            const existing = mode.source ? await this.loadExistingCategories(String(mode.source.id)) : [];
+            const diff = (0, categories_1.classifyChanges)(existing, snapshot.rows);
+            const historicalSourceIds = new Set(diff.rows.filter((row) => row.changeClass === 'removed').map((row) => row.sourceId));
+            let proposals = [];
+            let unresolvedLocalEntryIds = [];
+            if (mode.createLocalClone) {
+                // Clone entries do not exist yet; propose identity by remote sourceId and let
+                // apply bind them to the entry ids created inside the same transaction.
+                proposals = snapshot.rows.map((row) => ({
+                    proposalId: `clone:${row.sourceId}`,
+                    localEntryId: '',
+                    localLabel: row.title,
+                    localValue: row.sourceId,
+                    targetSourceId: row.sourceId,
+                    targetCategoryId: row.categoryId,
+                    targetTitle: row.title,
+                    matchType: 'identity',
+                    preselected: true,
+                    historical: false,
+                    evidence: { rule: 'clone-identity', normalizerVersion: categories_1.FIGSHARE_NORMALIZER_VERSION }
+                }));
+            }
+            else if (mode.localVocabulary) {
+                const localEntries = await this.loadLocalEntries(String(mode.localVocabulary.id));
+                const result = (0, categories_1.buildProposals)(localEntries, snapshot.rows, { historicalSourceIds });
+                proposals = result.proposals;
+                unresolvedLocalEntryIds = result.unresolvedLocalEntryIds;
+            }
+            const summary = {
+                ...diff.summary,
+                proposed: proposals.length,
+                preselected: proposals.filter((proposal) => proposal.preselected).length,
+                unresolved: unresolvedLocalEntryIds.length,
+                historicalWarnings: diff.summary.removed
+            };
+            const expiresAt = new Date(Date.now() + PREVIEW_TTL_MS).toISOString();
+            const run = await FigshareVocabularySyncRun.create({
+                branding: ctx.brandId,
+                source: mode.source ? String(mode.source.id) : null,
+                scope,
+                taxonomyId,
+                localVocabulary: mode.localVocabulary ? String(mode.localVocabulary.id) : null,
+                crosswalk: mode.crosswalk ? String(mode.crosswalk.id) : null,
+                createLocalClone: mode.createLocalClone,
+                localCloneName: String(input.localCloneName ?? '').trim() || undefined,
+                localCloneSlug: String(input.localCloneSlug ?? '').trim() || undefined,
+                normalizerVersion: categories_1.FIGSHARE_NORMALIZER_VERSION,
+                state: 'previewed',
+                baseHash: mode.source ? String(mode.source.remoteHash ?? '') : '',
+                remoteHash,
+                normalizedSnapshot: snapshot.rows,
+                diff: { rows: diff.rows, summary: diff.summary },
+                proposals,
+                summary,
+                warnings: [...snapshot.warnings, ...unresolvedLocalEntryIds.map((id) => ({ code: 'unresolved-local-entry', localEntryId: id }))],
+                expiresAt,
+                requestedBy: ctx.userId
+            }).fetch();
+            return this.toSyncPreview(run);
+        }
+        toSyncPreview(run) {
+            return {
+                runId: String(run.id),
+                state: String(run.state),
+                scope: run.scope,
+                taxonomyId: run.taxonomyId,
+                sourceId: run.source == null ? null : String(run.source),
+                localVocabularyId: run.localVocabulary == null ? null : String(run.localVocabulary),
+                crosswalkId: run.crosswalk == null ? null : String(run.crosswalk),
+                createLocalClone: run.createLocalClone === true,
+                baseHash: String(run.baseHash ?? ''),
+                remoteHash: String(run.remoteHash ?? ''),
+                expiresAt: run.expiresAt,
+                normalizerVersion: run.normalizerVersion,
+                summary: (run.summary ?? {}),
+                warnings: (run.warnings ?? [])
+            };
+        }
+        async getPreview(runId, query, ctx) {
+            const run = await this.requireRun(runId, ctx.brandId);
+            if ((run.state === 'previewed' || run.state === 'fetching') && new Date(run.expiresAt).getTime() <= Date.now()) {
+                await this.transitionRun(String(run.id), String(run.state), 'expired');
+                throw new vocabulary_errors_1.PreviewExpiredError();
+            }
+            const view = query?.view === 'diff' ? 'diff' : 'proposals';
+            const { limit, offset } = this.parsePaging(query?.limit, query?.offset);
+            const search = String(query?.q ?? '').trim().toLowerCase();
+            let records;
+            if (view === 'diff') {
+                const diffRows = (run.diff?.rows ?? []);
+                records = diffRows.filter((row) => {
+                    if (query?.changeClass && row.changeClass !== query.changeClass) {
+                        return false;
+                    }
+                    if (search && !`${row.sourceId} ${row.title}`.toLowerCase().includes(search)) {
+                        return false;
+                    }
+                    return true;
+                });
+            }
+            else {
+                const proposals = (run.proposals ?? []);
+                records = proposals.filter((proposal) => {
+                    if (query?.matchType && proposal.matchType !== query.matchType) {
+                        return false;
+                    }
+                    if (query?.historicalOnly === true && !proposal.historical) {
+                        return false;
+                    }
+                    if (query?.unresolvedOnly === true && proposal.preselected) {
+                        return false;
+                    }
+                    if (search) {
+                        const haystack = `${proposal.localLabel} ${proposal.localValue} ${proposal.targetSourceId} ${proposal.targetTitle}`.toLowerCase();
+                        if (!haystack.includes(search)) {
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+            }
+            const unresolvedIds = (run.warnings ?? [])
+                .filter((warning) => warning?.code === 'unresolved-local-entry' && warning.localEntryId)
+                .map((warning) => String(warning.localEntryId));
+            const unresolvedEntries = unresolvedIds.length === 0
+                ? []
+                : (await VocabularyEntry.find({ id: unresolvedIds })).map((entry) => ({
+                    localEntryId: String(entry.id),
+                    localLabel: String(entry.label ?? ''),
+                    localValue: String(entry.value ?? '')
+                }));
+            return {
+                ...this.toSyncPreview(run),
+                page: {
+                    view,
+                    records: records.slice(offset, offset + limit),
+                    total: records.length,
+                    limit,
+                    offset
+                },
+                unresolved: unresolvedEntries
+            };
+        }
+        // ── Apply ─────────────────────────────────────────────────────────
+        dedupeLabel(title, sourceId, usedLabels) {
+            // VocabularyEntry enforces a unique label per vocabulary while Figshare freely
+            // repeats titles across a taxonomy, so collisions are disambiguated by code.
+            const base = title.trim() || sourceId;
+            if (!usedLabels.has(base.toLowerCase())) {
+                usedLabels.add(base.toLowerCase());
+                return base;
+            }
+            let candidate = `${base} (${sourceId})`;
+            let suffix = 2;
+            while (usedLabels.has(candidate.toLowerCase())) {
+                candidate = `${base} (${sourceId}-${suffix})`;
+                suffix += 1;
+            }
+            usedLabels.add(candidate.toLowerCase());
+            return candidate;
+        }
+        async applyPreview(runId, decisions, ctx) {
+            const run = await this.requireRun(runId, ctx.brandId);
+            if (run.state === 'applied') {
+                // A completed run is idempotent: replay the stored result without writing.
+                return (run.result ?? {});
+            }
+            if (run.state === 'applying') {
+                throw new vocabulary_errors_1.StalePreviewError('This preview is already being applied');
+            }
+            if (run.state !== 'previewed') {
+                throw new vocabulary_errors_1.StalePreviewError(`This preview is '${run.state}' and can no longer be applied`);
+            }
+            if (new Date(run.expiresAt).getTime() <= Date.now()) {
+                await this.transitionRun(String(run.id), 'previewed', 'expired');
+                throw new vocabulary_errors_1.PreviewExpiredError();
+            }
+            if (String(decisions?.remoteHash ?? '') !== String(run.remoteHash ?? '')) {
+                throw new vocabulary_errors_1.StalePreviewError('The reviewed remote snapshot no longer matches this preview');
+            }
+            const existingSource = run.source ? await this.requireSource(String(run.source), ctx.brandId) : null;
+            if (existingSource && String(existingSource.remoteHash ?? '') !== String(run.baseHash ?? '')) {
+                throw new vocabulary_errors_1.StalePreviewError('The Figshare mirror changed since this preview was generated');
+            }
+            const existingCrosswalk = run.crosswalk ? await this.requireCrosswalk(String(run.crosswalk), ctx.brandId) : null;
+            if (existingCrosswalk && decisions?.expectedRevision != null
+                && Number(decisions.expectedRevision) !== Number(existingCrosswalk.workingRevision)) {
+                throw new vocabulary_errors_1.CrosswalkRevisionError();
+            }
+            await this.transitionRun(String(run.id), 'previewed', 'applying');
+            const createdIds = {
+                vocabularies: [],
+                sources: [],
+                crosswalks: []
+            };
+            try {
+                const result = await (0, TransactionUtils_1.runWithOptionalTransaction)(this.getDatastore(), async (connection) => this.applyPreviewWork(run, decisions, ctx, existingSource, existingCrosswalk, createdIds, connection), {
+                    logger: sails.log,
+                    unsupportedAdapterWarning: 'Transactions are not supported by this datastore adapter. Falling back to compensating cleanup for Figshare vocabulary apply.'
+                });
+                await this.transitionRun(String(run.id), 'applying', 'applied', {
+                    appliedBy: ctx.userId,
+                    appliedAt: result.appliedAt,
+                    source: result.sourceId,
+                    crosswalk: result.crosswalkId ?? null,
+                    localVocabulary: result.localVocabularyId ?? null,
+                    result: result
+                });
+                return result;
+            }
+            catch (error) {
+                await this.compensate(createdIds);
+                await this.transitionRun(String(run.id), 'applying', 'failed', {
+                    errorCode: error?.code ?? 'apply-failed',
+                    errorDetail: error?.message ?? 'Figshare vocabulary apply failed'
+                });
+                throw error;
+            }
+        }
+        /** Best-effort cleanup for datastores without transaction support. */
+        async compensate(created) {
+            try {
+                for (const crosswalkId of created.crosswalks) {
+                    await FigshareVocabularyCrosswalkMapping.destroy({ crosswalk: crosswalkId });
+                    await FigshareVocabularyCrosswalk.destroyOne({ id: crosswalkId });
+                }
+                for (const sourceId of created.sources) {
+                    await FigshareVocabularyCategory.destroy({ source: sourceId });
+                    await FigshareVocabularySource.destroyOne({ id: sourceId });
+                }
+                for (const vocabularyId of created.vocabularies) {
+                    await VocabularyEntry.destroy({ vocabulary: vocabularyId });
+                    await Vocabulary.destroyOne({ id: vocabularyId });
+                }
+            }
+            catch (cleanupError) {
+                sails.log.error('Figshare vocabulary apply compensation failed', cleanupError);
+            }
+        }
+        async applyPreviewWork(run, decisions, ctx, existingSource, existingCrosswalk, createdIds, connection) {
+            const snapshot = (run.normalizedSnapshot ?? []);
+            const appliedAt = this.nowIso();
+            // 1. Source + external mirror vocabulary.
+            let source = existingSource;
+            let mirrorVocabularyId;
+            if (source) {
+                mirrorVocabularyId = String(source.vocabulary);
+            }
+            else {
+                const mirrorName = `Figshare ${run.scope} taxonomy ${run.taxonomyId}`;
+                const mirror = await this.createOne(Vocabulary.create({
+                    name: mirrorName,
+                    description: `Read-only mirror of the Figshare ${run.scope} category catalogue for taxonomy ${run.taxonomyId}`,
+                    type: 'tree',
+                    source: 'external',
+                    sourceId: `${run.scope}:${run.taxonomyId}`,
+                    figshareSourceKey: `${ctx.brandId}:${run.scope}:${run.taxonomyId}`,
+                    branding: ctx.brandId
+                }), connection);
+                mirrorVocabularyId = String(mirror.id);
+                createdIds.vocabularies.push(mirrorVocabularyId);
+                source = await this.createOne(FigshareVocabularySource.create({
+                    branding: ctx.brandId,
+                    vocabulary: mirrorVocabularyId,
+                    scope: run.scope,
+                    taxonomyId: run.taxonomyId,
+                    displayName: mirrorName,
+                    createdBy: ctx.userId,
+                    updatedBy: ctx.userId
+                }), connection);
+                createdIds.sources.push(String(source.id));
+            }
+            const sourceId = String(source.id);
+            // 2/3. Upsert category relationships and mirrored entries, then mark omissions historical.
+            const mirrorStats = await this.syncMirror(sourceId, mirrorVocabularyId, snapshot, appliedAt, connection);
+            // 4. Optional independent local clone.
+            let localVocabularyId = run.localVocabulary == null ? null : String(run.localVocabulary);
+            let cloneCreated = false;
+            let cloneEntryBySourceId = new Map();
+            if (run.createLocalClone === true && !localVocabularyId) {
+                const clone = await this.createCloneVocabulary(String(run.localCloneName ?? '').trim(), String(run.localCloneSlug ?? '').trim(), snapshot, ctx, connection);
+                localVocabularyId = clone.vocabularyId;
+                cloneEntryBySourceId = clone.entryBySourceId;
+                cloneCreated = true;
+                createdIds.vocabularies.push(localVocabularyId);
+            }
+            // 5. Crosswalk and mapping edges.
+            let crosswalkId = existingCrosswalk ? String(existingCrosswalk.id) : null;
+            let crosswalkRevision = existingCrosswalk ? Number(existingCrosswalk.workingRevision) : null;
+            let mappingStats = { created: 0, removed: 0 };
+            if (localVocabularyId) {
+                if (!crosswalkId) {
+                    // A clone knows its own name up front; an existing local vocabulary has to be
+                    // read back so the crosswalk is labelled after it rather than a generic stand-in.
+                    let localLabel = String(run.localCloneName ?? '').trim();
+                    if (!localLabel) {
+                        const localVocabulary = await this.runQuery(Vocabulary.findOne({ id: localVocabularyId }), connection);
+                        localLabel = String(localVocabulary?.name ?? '').trim();
+                    }
+                    const crosswalkName = await this.uniqueCrosswalkName(`${localLabel || 'Crosswalk'} → Figshare taxonomy ${run.taxonomyId}`, ctx.brandId, connection);
+                    const crosswalk = await this.createOne(FigshareVocabularyCrosswalk.create({
+                        branding: ctx.brandId,
+                        name: crosswalkName,
+                        localVocabulary: localVocabularyId,
+                        figshareSource: sourceId,
+                        status: 'draft',
+                        workingRevision: 1,
+                        updatedBy: ctx.userId
+                    }), connection);
+                    crosswalkId = String(crosswalk.id);
+                    crosswalkRevision = 1;
+                    createdIds.crosswalks.push(crosswalkId);
+                }
+                mappingStats = await this.writeMappingEdges(crosswalkId, crosswalkRevision ?? 1, run, decisions, sourceId, localVocabularyId, cloneEntryBySourceId, ctx, connection);
+            }
+            // 6. Source cursor.
+            await this.runQuery(FigshareVocabularySource.updateOne({ id: sourceId }).set({
+                remoteHash: String(run.remoteHash ?? ''),
+                lastSyncedAt: appliedAt,
+                lastSyncRun: String(run.id),
+                updatedBy: ctx.userId
+            }), connection);
+            return {
+                runId: String(run.id),
+                state: 'applied',
+                sourceId,
+                vocabularyId: mirrorVocabularyId,
+                localVocabularyId,
+                crosswalkId,
+                crosswalkRevision,
+                categories: mirrorStats,
+                mappings: mappingStats,
+                cloneCreated,
+                appliedAt
+            };
+        }
+        async syncMirror(sourceId, mirrorVocabularyId, snapshot, appliedAt, connection) {
+            const existingCategories = await this.runQuery(FigshareVocabularyCategory.find({ source: sourceId }), connection);
+            const existingBySourceId = new Map(existingCategories.map((category) => [category.sourceId, category]));
+            const existingEntries = await this.runQuery(VocabularyEntry.find({ vocabulary: mirrorVocabularyId }), connection);
+            const usedLabels = new Set(existingEntries.map((entry) => String(entry.labelLower ?? '')));
+            const entryIdByCategoryId = new Map(existingCategories.map((category) => [category.sourceId, String(category.entry)]));
+            const stats = { created: 0, updated: 0, historical: 0, reappeared: 0 };
+            const entryIdBySourceId = new Map();
+            for (const row of snapshot) {
+                const existing = existingBySourceId.get(row.sourceId);
+                if (!existing) {
+                    const label = this.dedupeLabel(row.title, row.sourceId, usedLabels);
+                    const entry = await this.createOne(VocabularyEntry.create({
+                        vocabulary: mirrorVocabularyId,
+                        label,
+                        value: row.sourceId,
+                        identifier: row.sourceId,
+                        order: 0,
+                        historical: false
+                    }), connection);
+                    entryIdBySourceId.set(row.sourceId, String(entry.id));
+                    await this.createOne(FigshareVocabularyCategory.create({
+                        source: sourceId,
+                        entry: String(entry.id),
+                        sourceId: row.sourceId,
+                        categoryId: row.categoryId,
+                        taxonomyId: row.taxonomyId,
+                        parentSourceId: row.parentSourceId ?? undefined,
+                        path: row.path,
+                        selectable: row.selectable,
+                        historical: false,
+                        firstSeenAt: appliedAt,
+                        lastSeenAt: appliedAt,
+                        contentHash: row.contentHash
+                    }), connection);
+                    stats.created += 1;
+                    continue;
+                }
+                const entryId = String(existing.entry);
+                entryIdBySourceId.set(row.sourceId, entryId);
+                const wasHistorical = existing.historical === true;
+                if (wasHistorical) {
+                    stats.reappeared += 1;
+                }
+                else if (existing.contentHash !== row.contentHash) {
+                    stats.updated += 1;
+                }
+                if (wasHistorical || existing.contentHash !== row.contentHash) {
+                    await this.runQuery(VocabularyEntry.updateOne({ id: entryId }).set({
+                        label: this.relabelExisting(row, existingEntries, entryId, usedLabels),
+                        historical: false
+                    }), connection);
+                }
+                await this.runQuery(FigshareVocabularyCategory.updateOne({ id: String(existing.id) }).set({
+                    categoryId: row.categoryId,
+                    taxonomyId: row.taxonomyId,
+                    parentSourceId: row.parentSourceId ?? undefined,
+                    path: row.path,
+                    selectable: row.selectable,
+                    historical: false,
+                    lastSeenAt: appliedAt,
+                    contentHash: row.contentHash
+                }), connection);
+            }
+            // Remote omission never hard-deletes: retain identity and audit evidence.
+            const remoteSourceIds = new Set(snapshot.map((row) => row.sourceId));
+            for (const existing of existingCategories) {
+                if (remoteSourceIds.has(existing.sourceId) || existing.historical === true) {
+                    continue;
+                }
+                await this.runQuery(FigshareVocabularyCategory.updateOne({ id: String(existing.id) }).set({ historical: true }), connection);
+                await this.runQuery(VocabularyEntry.updateOne({ id: String(existing.entry) }).set({ historical: true }), connection);
+                stats.historical += 1;
+            }
+            // Parents are rebuilt after every entry exists so ordering never matters.
+            for (const row of snapshot) {
+                const entryId = entryIdBySourceId.get(row.sourceId) ?? entryIdByCategoryId.get(row.sourceId);
+                if (!entryId) {
+                    continue;
+                }
+                const parentEntryId = row.parentSourceId == null
+                    ? null
+                    : entryIdBySourceId.get(row.parentSourceId) ?? entryIdByCategoryId.get(row.parentSourceId) ?? null;
+                await this.runQuery(VocabularyEntry.updateOne({ id: entryId }).set({ parent: parentEntryId }), connection);
+            }
+            return stats;
+        }
+        relabelExisting(row, existingEntries, entryId, usedLabels) {
+            const current = existingEntries.find((entry) => String(entry.id) === entryId);
+            const currentLabelLower = String(current?.labelLower ?? '');
+            if (currentLabelLower === row.title.toLowerCase()) {
+                return row.title;
+            }
+            usedLabels.delete(currentLabelLower);
+            return this.dedupeLabel(row.title, row.sourceId, usedLabels);
+        }
+        async createCloneVocabulary(name, slug, snapshot, ctx, connection) {
+            if (!name) {
+                throw new vocabulary_errors_1.CatalogueInvalidError('A clone name is required to create an editable local vocabulary');
+            }
+            const clone = await this.createOne(Vocabulary.create({
+                name,
+                ...(slug ? { slug } : {}),
+                description: 'Editable local copy of a Figshare category catalogue',
+                type: 'tree',
+                source: 'local',
+                branding: ctx.brandId
+            }), connection);
+            const vocabularyId = String(clone.id);
+            const usedLabels = new Set();
+            const entryBySourceId = new Map();
+            for (const row of snapshot) {
+                const entry = await this.createOne(VocabularyEntry.create({
+                    vocabulary: vocabularyId,
+                    label: this.dedupeLabel(row.title, row.sourceId, usedLabels),
+                    value: row.sourceId,
+                    identifier: row.sourceId,
+                    order: 0,
+                    historical: false
+                }), connection);
+                entryBySourceId.set(row.sourceId, String(entry.id));
+            }
+            // Parent references are rebuilt against clone entry ids once all entries exist.
+            for (const row of snapshot) {
+                const entryId = entryBySourceId.get(row.sourceId);
+                const parentId = row.parentSourceId == null ? null : entryBySourceId.get(row.parentSourceId) ?? null;
+                if (!entryId || parentId == null) {
+                    continue;
+                }
+                await this.runQuery(VocabularyEntry.updateOne({ id: entryId }).set({ parent: parentId }), connection);
+            }
+            return { vocabularyId, entryBySourceId };
+        }
+        async uniqueCrosswalkName(base, brandId, connection) {
+            let candidate = base;
+            let suffix = 2;
+            // The unique { branding, name } index makes collisions a hard failure, so probe first.
+            while (await this.runQuery(FigshareVocabularyCrosswalk.findOne({ branding: brandId, name: candidate }), connection)) {
+                candidate = `${base} (${suffix})`;
+                suffix += 1;
+            }
+            return candidate;
+        }
+        async writeMappingEdges(crosswalkId, revision, run, decisions, sourceId, localVocabularyId, cloneEntryBySourceId, ctx, connection) {
+            const categories = await this.runQuery(FigshareVocabularyCategory.find({ source: sourceId }), connection);
+            const categoryBySourceId = new Map(categories.map((category) => [category.sourceId, category]));
+            const approvedProposalIds = new Set((decisions?.approvedProposalIds ?? []).map((id) => String(id)));
+            const proposals = (run.proposals ?? []);
+            const desiredEdges = new Map();
+            const addEdge = (localEntryId, categorySourceId, matchType) => {
+                const category = categoryBySourceId.get(categorySourceId);
+                if (!localEntryId || !category) {
+                    return;
+                }
+                desiredEdges.set(`${localEntryId}::${String(category.id)}`, {
+                    localEntryId,
+                    categoryId: String(category.id),
+                    matchType
+                });
+            };
+            for (const proposal of proposals) {
+                if (!approvedProposalIds.has(proposal.proposalId)) {
+                    continue;
+                }
+                const localEntryId = proposal.localEntryId
+                    || cloneEntryBySourceId.get(proposal.targetSourceId)
+                    || '';
+                addEdge(localEntryId, proposal.targetSourceId, proposal.matchType);
+            }
+            const manualMappings = decisions?.manualMappings ?? [];
+            if (manualMappings.length > MAX_MAPPING_BATCH) {
+                throw new vocabulary_errors_1.CatalogueInvalidError(`manualMappings exceeds the maximum batch size of ${MAX_MAPPING_BATCH}`);
+            }
+            for (const mapping of manualMappings) {
+                const localEntryId = String(mapping.localEntryId ?? '').trim()
+                    || cloneEntryBySourceId.get(String(mapping.localEntryKey ?? '').trim())
+                    || '';
+                for (const targetSourceId of mapping.figshareSourceIds ?? []) {
+                    addEdge(localEntryId, String(targetSourceId).trim(), 'manual');
+                }
+            }
+            if (desiredEdges.size > 0) {
+                const localEntryIds = Array.from(new Set(Array.from(desiredEdges.values()).map((edge) => edge.localEntryId)));
+                const localEntries = await this.runQuery(VocabularyEntry.find({ id: localEntryIds, vocabulary: localVocabularyId }), connection);
+                const validLocalEntryIds = new Set(localEntries.map((entry) => String(entry.id)));
+                for (const edge of desiredEdges.values()) {
+                    if (!validLocalEntryIds.has(edge.localEntryId)) {
+                        throw new vocabulary_errors_1.RelationshipBoundaryError('A mapping references a local entry outside the crosswalk local vocabulary');
+                    }
+                }
+            }
+            const existingEdges = await this.runQuery(FigshareVocabularyCrosswalkMapping.find({ crosswalk: crosswalkId, revision }), connection);
+            const existingKeys = new Set(existingEdges.map((edge) => `${String(edge.localEntry)}::${String(edge.figshareCategory)}`));
+            let created = 0;
+            for (const [key, edge] of desiredEdges) {
+                if (existingKeys.has(key)) {
+                    continue;
+                }
+                await this.createOne(FigshareVocabularyCrosswalkMapping.create({
+                    crosswalk: crosswalkId,
+                    revision,
+                    localEntry: edge.localEntryId,
+                    figshareCategory: edge.categoryId,
+                    status: 'proposed',
+                    matchType: edge.matchType
+                }), connection);
+                created += 1;
+            }
+            await this.runQuery(FigshareVocabularyCrosswalk.updateOne({ id: crosswalkId }).set({ updatedBy: ctx.userId }), connection);
+            return { created, removed: 0 };
+        }
+        // ── Sources ───────────────────────────────────────────────────────
+        async listSources(query, ctx) {
+            const { limit, offset } = this.parsePaging(query?.limit, query?.offset, 25);
+            const where = { branding: ctx.brandId };
+            if (query?.scope === 'public' || query?.scope === 'account') {
+                where.scope = query.scope;
+            }
+            const search = String(query?.q ?? '').trim();
+            if (search) {
+                where.displayName = { contains: search };
+            }
+            const total = await FigshareVocabularySource.count(where);
+            const sources = await FigshareVocabularySource.find(where)
+                .sort('displayName ASC')
+                .skip(offset)
+                .limit(limit);
+            const data = await Promise.all(sources.map((source) => this.describeSource(source)));
+            return { data, meta: { total, limit, offset } };
+        }
+        async getSource(sourceId, ctx) {
+            return this.describeSource(await this.requireSource(sourceId, ctx.brandId));
+        }
+        /**
+         * Search the mirrored categories of one source so an operator can pick a manual
+         * crosswalk target. Historical targets stay hidden unless explicitly requested:
+         * mapping to a retired Figshare category is a deliberate act, not a default.
+         */
+        async listSourceCategories(sourceId, query, ctx) {
+            const source = await this.requireSource(sourceId, ctx.brandId);
+            const { limit, offset } = this.parsePaging(query?.limit, query?.offset, 25);
+            const where = { source: String(source.id) };
+            if (query?.includeHistorical !== true) {
+                where.historical = false;
+            }
+            if (query?.selectableOnly === true) {
+                where.selectable = true;
+            }
+            const categories = await FigshareVocabularyCategory.find(where);
+            const titleByEntryId = await this.loadCategoryTitles(categories);
+            const search = String(query?.q ?? '').trim().toLowerCase();
+            const rows = categories
+                .map((category) => ({
+                id: String(category.id),
+                sourceId: String(category.sourceId),
+                categoryId: Number(category.categoryId),
+                title: titleByEntryId.get(String(category.entry)) ?? String(category.sourceId),
+                parentSourceId: category.parentSourceId,
+                selectable: category.selectable !== false,
+                historical: category.historical === true
+            }))
+                .filter((row) => !search
+                || `${row.title} ${row.sourceId} ${row.categoryId}`.toLowerCase().includes(search))
+                .sort((left, right) => left.sourceId.localeCompare(right.sourceId, undefined, { numeric: true }));
+            return {
+                data: rows.slice(offset, offset + limit),
+                meta: { total: rows.length, limit, offset }
+            };
+        }
+        /** Mirrored category titles live on the linked vocabulary entry, not the category row. */
+        async loadCategoryTitles(categories) {
+            if (categories.length === 0) {
+                return new Map();
+            }
+            const entryIds = Array.from(new Set(categories.map((category) => String(category.entry))));
+            const entries = await VocabularyEntry.find({ id: entryIds });
+            return new Map(entries.map((entry) => [String(entry.id), String(entry.label ?? '')]));
+        }
+        async describeSource(source) {
+            const sourceId = String(source.id);
+            const [mirroredCount, historicalCount, crosswalkCount] = await Promise.all([
+                FigshareVocabularyCategory.count({ source: sourceId, historical: false }),
+                FigshareVocabularyCategory.count({ source: sourceId, historical: true }),
+                FigshareVocabularyCrosswalk.count({ figshareSource: sourceId })
+            ]);
+            const vocabulary = await Vocabulary.findOne({ id: String(source.vocabulary) });
+            return {
+                id: sourceId,
+                displayName: source.displayName,
+                scope: source.scope,
+                taxonomyId: source.taxonomyId,
+                vocabularyId: String(source.vocabulary),
+                vocabularyName: vocabulary?.name ?? '',
+                lastSyncedAt: source.lastSyncedAt ?? null,
+                archived: source.archived === true,
+                mirroredCount,
+                historicalCount,
+                crosswalkCount
+            };
+        }
+        async listSyncRuns(query, ctx) {
+            const { limit, offset } = this.parsePaging(query?.limit, query?.offset, 25);
+            const where = { branding: ctx.brandId };
+            const sourceId = String(query?.sourceId ?? '').trim();
+            if (sourceId) {
+                where.source = sourceId;
+            }
+            const total = await FigshareVocabularySyncRun.count(where);
+            const runs = await FigshareVocabularySyncRun.find(where)
+                .sort('createdAt DESC')
+                .skip(offset)
+                .limit(limit);
+            return {
+                data: runs.map((run) => ({
+                    id: String(run.id),
+                    state: run.state,
+                    scope: run.scope,
+                    taxonomyId: run.taxonomyId,
+                    sourceId: run.source == null ? null : String(run.source),
+                    summary: run.summary ?? {},
+                    requestedBy: run.requestedBy,
+                    appliedBy: run.appliedBy ?? null,
+                    appliedAt: run.appliedAt ?? null,
+                    expiresAt: run.expiresAt,
+                    errorCode: run.errorCode ?? null
+                })),
+                meta: { total, limit, offset }
+            };
+        }
+        /**
+         * Create an independent editable local vocabulary from an existing mirror plus a
+         * draft identity crosswalk. Later mirror synchronisation never edits clone terms.
+         */
+        async cloneMirror(sourceId, cloneInput, ctx) {
+            const source = await this.requireSource(sourceId, ctx.brandId);
+            const categories = await FigshareVocabularyCategory.find({
+                source: String(source.id),
+                historical: false
+            });
+            if (categories.length === 0) {
+                throw new vocabulary_errors_1.CatalogueInvalidError('The Figshare mirror has no current categories to clone');
+            }
+            const snapshot = categories.map((category) => ({
+                sourceId: category.sourceId,
+                categoryId: category.categoryId,
+                taxonomyId: category.taxonomyId,
+                title: '',
+                parentSourceId: category.parentSourceId ?? null,
+                path: category.path ?? [category.sourceId],
+                selectable: category.selectable !== false,
+                hasChildren: false,
+                contentHash: category.contentHash
+            }));
+            const entries = await VocabularyEntry.find({
+                id: categories.map((category) => String(category.entry))
+            });
+            const labelByEntryId = new Map(entries.map((entry) => [String(entry.id), String(entry.label ?? '')]));
+            for (const [index, category] of categories.entries()) {
+                snapshot[index].title = labelByEntryId.get(String(category.entry)) ?? category.sourceId;
+            }
+            const createdIds = {
+                vocabularies: [],
+                sources: [],
+                crosswalks: []
+            };
+            try {
+                return await (0, TransactionUtils_1.runWithOptionalTransaction)(this.getDatastore(), async (connection) => {
+                    const clone = await this.createCloneVocabulary(String(cloneInput?.name ?? '').trim(), String(cloneInput?.slug ?? '').trim(), snapshot, ctx, connection);
+                    createdIds.vocabularies.push(clone.vocabularyId);
+                    const crosswalkName = await this.uniqueCrosswalkName(`${String(cloneInput.name).trim()} → ${source.displayName}`, ctx.brandId, connection);
+                    const crosswalk = await this.createOne(FigshareVocabularyCrosswalk.create({
+                        branding: ctx.brandId,
+                        name: crosswalkName,
+                        localVocabulary: clone.vocabularyId,
+                        figshareSource: String(source.id),
+                        status: 'draft',
+                        workingRevision: 1,
+                        updatedBy: ctx.userId
+                    }), connection);
+                    createdIds.crosswalks.push(String(crosswalk.id));
+                    const cloneEntries = Array.from(clone.entryBySourceId.entries()).map(([entrySourceId, entryId]) => ({
+                        id: entryId,
+                        label: '',
+                        labelLower: '',
+                        value: entrySourceId,
+                        valueLower: entrySourceId.toLowerCase(),
+                        sourceId: entrySourceId
+                    }));
+                    const identity = (0, categories_1.buildIdentityProposals)(cloneEntries, snapshot);
+                    const categoryBySourceId = new Map(categories.map((category) => [category.sourceId, category]));
+                    for (const proposal of identity.proposals) {
+                        const category = categoryBySourceId.get(proposal.targetSourceId);
+                        if (!category) {
+                            continue;
+                        }
+                        await this.createOne(FigshareVocabularyCrosswalkMapping.create({
+                            crosswalk: String(crosswalk.id),
+                            revision: 1,
+                            localEntry: proposal.localEntryId,
+                            figshareCategory: String(category.id),
+                            status: 'proposed',
+                            matchType: 'identity'
+                        }), connection);
+                    }
+                    return {
+                        localVocabularyId: clone.vocabularyId,
+                        crosswalkId: String(crosswalk.id),
+                        entries: clone.entryBySourceId.size
+                    };
+                }, {
+                    logger: sails.log,
+                    unsupportedAdapterWarning: 'Transactions are not supported by this datastore adapter. Falling back to compensating cleanup for Figshare clone.'
+                });
+            }
+            catch (error) {
+                await this.compensate(createdIds);
+                throw error;
+            }
+        }
+        // ── Crosswalks ────────────────────────────────────────────────────
+        async listCrosswalks(query, ctx) {
+            const { limit, offset } = this.parsePaging(query?.limit, query?.offset, 25);
+            const where = { branding: ctx.brandId };
+            if (query?.status) {
+                where.status = String(query.status);
+            }
+            if (query?.localVocabularyId) {
+                where.localVocabulary = String(query.localVocabularyId);
+            }
+            if (query?.sourceId) {
+                where.figshareSource = String(query.sourceId);
+            }
+            const search = String(query?.q ?? '').trim();
+            if (search) {
+                where.name = { contains: search };
+            }
+            const total = await FigshareVocabularyCrosswalk.count(where);
+            const crosswalks = await FigshareVocabularyCrosswalk.find(where)
+                .sort('name ASC')
+                .skip(offset)
+                .limit(limit);
+            const data = await Promise.all(crosswalks.map((crosswalk) => this.describeCrosswalk(crosswalk)));
+            return { data, meta: { total, limit, offset } };
+        }
+        async getCrosswalk(crosswalkId, ctx) {
+            return this.describeCrosswalk(await this.requireCrosswalk(crosswalkId, ctx.brandId));
+        }
+        async describeCrosswalk(crosswalk) {
+            const crosswalkId = String(crosswalk.id);
+            const [localVocabulary, source] = await Promise.all([
+                Vocabulary.findOne({ id: String(crosswalk.localVocabulary) }),
+                FigshareVocabularySource.findOne({ id: String(crosswalk.figshareSource) })
+            ]);
+            const [approvedMappingCount, workingMappingCount] = await Promise.all([
+                crosswalk.approvedRevision == null
+                    ? Promise.resolve(0)
+                    : FigshareVocabularyCrosswalkMapping.count({
+                        crosswalk: crosswalkId,
+                        revision: Number(crosswalk.approvedRevision),
+                        status: 'approved'
+                    }),
+                FigshareVocabularyCrosswalkMapping.count({ crosswalk: crosswalkId, revision: Number(crosswalk.workingRevision) })
+            ]);
+            const historicalTargetCount = await this.countHistoricalTargets(crosswalkId, crosswalk);
+            return {
+                id: crosswalkId,
+                name: crosswalk.name,
+                status: String(crosswalk.status),
+                workingRevision: Number(crosswalk.workingRevision),
+                approvedRevision: crosswalk.approvedRevision ?? null,
+                approvedAt: crosswalk.approvedAt,
+                approvedBy: crosswalk.approvedBy,
+                localVocabularyId: String(crosswalk.localVocabulary),
+                localVocabularyName: localVocabulary?.name ?? '',
+                figshareSourceId: String(crosswalk.figshareSource),
+                figshareSourceName: source?.displayName ?? '',
+                scope: String(source?.scope ?? ''),
+                taxonomyId: String(source?.taxonomyId ?? ''),
+                approvedMappingCount,
+                workingMappingCount,
+                historicalTargetCount
+            };
+        }
+        async countHistoricalTargets(crosswalkId, crosswalk) {
+            const revision = Number(crosswalk.approvedRevision ?? crosswalk.workingRevision);
+            const mappings = await FigshareVocabularyCrosswalkMapping.find({
+                crosswalk: crosswalkId,
+                revision
+            });
+            if (mappings.length === 0) {
+                return 0;
+            }
+            const categoryIds = Array.from(new Set(mappings.map((mapping) => String(mapping.figshareCategory))));
+            return FigshareVocabularyCategory.count({ id: categoryIds, historical: true });
+        }
+        async createCrosswalk(input, ctx) {
+            const name = String(input?.name ?? '').trim();
+            if (!name) {
+                throw new vocabulary_errors_1.CatalogueInvalidError('name is required');
+            }
+            const localVocabulary = await this.requireLocalVocabulary(String(input?.localVocabularyId ?? ''), ctx.brandId);
+            const source = await this.requireSource(String(input?.sourceId ?? ''), ctx.brandId);
+            const existing = await FigshareVocabularyCrosswalk.findOne({ branding: ctx.brandId, name });
+            if (existing) {
+                throw new vocabulary_errors_1.RelationshipBoundaryError(`A crosswalk named '${name}' already exists for this brand`);
+            }
+            const crosswalk = await FigshareVocabularyCrosswalk.create({
+                branding: ctx.brandId,
+                name,
+                localVocabulary: String(localVocabulary.id),
+                figshareSource: String(source.id),
+                status: 'draft',
+                workingRevision: 1,
+                updatedBy: ctx.userId
+            }).fetch();
+            return this.describeCrosswalk(crosswalk);
+        }
+        /**
+         * Search the local vocabulary behind a crosswalk, annotated with how many targets
+         * each term already has. Terms with no target never appear in the mapping table,
+         * so this is the only way the manual picker can reach them.
+         */
+        async listCrosswalkLocalEntries(crosswalkId, query, ctx) {
+            const crosswalk = await this.requireCrosswalk(crosswalkId, ctx.brandId);
+            const { limit, offset } = this.parsePaging(query?.limit, query?.offset, 25);
+            const revision = Number(query?.revision ?? crosswalk.workingRevision);
+            const [entries, mappings] = await Promise.all([
+                VocabularyEntry.find({ vocabulary: String(crosswalk.localVocabulary) }),
+                FigshareVocabularyCrosswalkMapping.find({
+                    crosswalk: String(crosswalk.id),
+                    revision
+                })
+            ]);
+            const targetCountByEntryId = new Map();
+            for (const mapping of mappings) {
+                const key = String(mapping.localEntry);
+                targetCountByEntryId.set(key, (targetCountByEntryId.get(key) ?? 0) + 1);
+            }
+            const search = String(query?.q ?? '').trim().toLowerCase();
+            const mappedFilter = String(query?.mapped ?? '').trim().toLowerCase();
+            const rows = entries
+                .map((entry) => ({
+                id: String(entry.id),
+                label: String(entry.label ?? ''),
+                value: String(entry.value ?? ''),
+                identifier: entry.identifier,
+                historical: entry.historical === true,
+                targetCount: targetCountByEntryId.get(String(entry.id)) ?? 0
+            }))
+                .filter((row) => !search || `${row.label} ${row.value}`.toLowerCase().includes(search))
+                .filter((row) => {
+                if (mappedFilter === 'unmapped') {
+                    return row.targetCount === 0;
+                }
+                if (mappedFilter === 'mapped') {
+                    return row.targetCount > 0;
+                }
+                return true;
+            })
+                .sort((left, right) => left.label.localeCompare(right.label));
+            return {
+                data: rows.slice(offset, offset + limit),
+                meta: { total: rows.length, limit, offset, revision }
+            };
+        }
+        async listCrosswalkMappings(crosswalkId, query, ctx) {
+            const crosswalk = await this.requireCrosswalk(crosswalkId, ctx.brandId);
+            const { limit, offset } = this.parsePaging(query?.limit, query?.offset);
+            const revision = Number(query?.revision ?? crosswalk.workingRevision);
+            const where = { crosswalk: String(crosswalk.id), revision };
+            if (query?.status) {
+                where.status = String(query.status);
+            }
+            const mappings = await FigshareVocabularyCrosswalkMapping.find(where);
+            const [entries, categories] = await Promise.all([
+                mappings.length === 0
+                    ? Promise.resolve([])
+                    : VocabularyEntry.find({ id: Array.from(new Set(mappings.map((mapping) => String(mapping.localEntry)))) }),
+                mappings.length === 0
+                    ? Promise.resolve([])
+                    : FigshareVocabularyCategory.find({ id: Array.from(new Set(mappings.map((mapping) => String(mapping.figshareCategory)))) })
+            ]);
+            const entryById = new Map(entries.map((entry) => [String(entry.id), entry]));
+            const categoryById = new Map(categories.map((category) => [String(category.id), category]));
+            const search = String(query?.q ?? '').trim().toLowerCase();
+            const rows = mappings
+                .map((mapping) => {
+                const entry = entryById.get(String(mapping.localEntry));
+                const category = categoryById.get(String(mapping.figshareCategory));
+                return {
+                    id: String(mapping.id),
+                    revision: mapping.revision,
+                    status: mapping.status,
+                    matchType: mapping.matchType,
+                    localEntryId: String(mapping.localEntry),
+                    localLabel: String(entry?.label ?? ''),
+                    localValue: String(entry?.value ?? ''),
+                    figshareCategoryId: String(mapping.figshareCategory),
+                    figshareSourceId: String(category?.sourceId ?? ''),
+                    figshareCategoryNumber: category?.categoryId ?? null,
+                    historical: category?.historical === true,
+                    approvedAt: mapping.approvedAt ?? null,
+                    approvedBy: mapping.approvedBy ?? null
+                };
+            })
+                .filter((row) => !search || `${row.localLabel} ${row.localValue} ${row.figshareSourceId}`.toLowerCase().includes(search))
+                .sort((left, right) => left.localLabel.localeCompare(right.localLabel));
+            return {
+                data: rows.slice(offset, offset + limit),
+                meta: { total: rows.length, limit, offset, revision }
+            };
+        }
+        /**
+         * Batch upsert/delete mapping edges under optimistic revision control. The first
+         * edit of an approved crosswalk copies the approved rows into a new working
+         * revision so publishing continues against the previous approved snapshot.
+         */
+        async saveMappings(crosswalkId, input, ctx) {
+            const crosswalk = await this.requireCrosswalk(crosswalkId, ctx.brandId);
+            const changes = input?.changes ?? [];
+            if (changes.length > MAX_MAPPING_BATCH) {
+                throw new vocabulary_errors_1.CatalogueInvalidError(`changes exceeds the maximum batch size of ${MAX_MAPPING_BATCH}`);
+            }
+            if (Number(input?.revision) !== Number(crosswalk.workingRevision)) {
+                throw new vocabulary_errors_1.CrosswalkRevisionError();
+            }
+            return (0, TransactionUtils_1.runWithOptionalTransaction)(this.getDatastore(), async (connection) => {
+                let workingRevision = Number(crosswalk.workingRevision);
+                if (crosswalk.approvedRevision != null && Number(crosswalk.approvedRevision) === workingRevision) {
+                    workingRevision += 1;
+                    const approvedRows = await this.runQuery(FigshareVocabularyCrosswalkMapping.find({
+                        crosswalk: String(crosswalk.id),
+                        revision: Number(crosswalk.approvedRevision)
+                    }), connection);
+                    for (const row of approvedRows) {
+                        await this.createOne(FigshareVocabularyCrosswalkMapping.create({
+                            crosswalk: String(crosswalk.id),
+                            revision: workingRevision,
+                            localEntry: String(row.localEntry),
+                            figshareCategory: String(row.figshareCategory),
+                            status: row.status,
+                            matchType: row.matchType,
+                            evidence: row.evidence,
+                            approvedAt: row.approvedAt,
+                            approvedBy: row.approvedBy
+                        }), connection);
+                    }
+                    await this.runQuery(FigshareVocabularyCrosswalk.updateOne({ id: String(crosswalk.id) }).set({ workingRevision }), connection);
+                }
+                for (const change of changes) {
+                    const localEntryId = String(change?.localEntryId ?? '').trim();
+                    const figshareCategoryId = String(change?.figshareCategoryId ?? '').trim();
+                    if (!localEntryId || !figshareCategoryId) {
+                        throw new vocabulary_errors_1.CatalogueInvalidError('Each change requires localEntryId and figshareCategoryId');
+                    }
+                    await this.assertMappingOwnership(crosswalk, localEntryId, figshareCategoryId, connection);
+                    if (change.op === 'remove') {
+                        await this.runQuery(FigshareVocabularyCrosswalkMapping.destroy({
+                            crosswalk: String(crosswalk.id),
+                            revision: workingRevision,
+                            localEntry: localEntryId,
+                            figshareCategory: figshareCategoryId
+                        }), connection);
+                        continue;
+                    }
+                    const existing = await this.runQuery(FigshareVocabularyCrosswalkMapping.findOne({
+                        crosswalk: String(crosswalk.id),
+                        revision: workingRevision,
+                        localEntry: localEntryId,
+                        figshareCategory: figshareCategoryId
+                    }), connection);
+                    const status = change.status ?? 'proposed';
+                    const approvalPatch = status === 'approved'
+                        ? { approvedAt: this.nowIso(), approvedBy: ctx.userId }
+                        : { approvedAt: undefined, approvedBy: undefined };
+                    if (existing) {
+                        await this.runQuery(FigshareVocabularyCrosswalkMapping.updateOne({ id: String(existing.id) }).set({
+                            status,
+                            matchType: change.matchType ?? existing.matchType,
+                            ...approvalPatch
+                        }), connection);
+                        continue;
+                    }
+                    await this.createOne(FigshareVocabularyCrosswalkMapping.create({
+                        crosswalk: String(crosswalk.id),
+                        revision: workingRevision,
+                        localEntry: localEntryId,
+                        figshareCategory: figshareCategoryId,
+                        status,
+                        matchType: change.matchType ?? 'manual',
+                        ...approvalPatch
+                    }), connection);
+                }
+                await this.runQuery(FigshareVocabularyCrosswalk.updateOne({ id: String(crosswalk.id) }).set({ updatedBy: ctx.userId }), connection);
+                const refreshed = await this.runQuery(FigshareVocabularyCrosswalk.findOne({ id: String(crosswalk.id) }), connection);
+                return this.describeCrosswalk(refreshed ?? crosswalk);
+            }, {
+                logger: sails.log,
+                unsupportedAdapterWarning: 'Transactions are not supported by this datastore adapter. Falling back to non-transactional crosswalk mapping save.'
+            });
+        }
+        async assertMappingOwnership(crosswalk, localEntryId, figshareCategoryId, connection) {
+            const entry = await this.runQuery(VocabularyEntry.findOne({ id: localEntryId, vocabulary: String(crosswalk.localVocabulary) }), connection);
+            if (!entry) {
+                throw new vocabulary_errors_1.RelationshipBoundaryError('The local entry does not belong to the crosswalk local vocabulary');
+            }
+            const category = await this.runQuery(FigshareVocabularyCategory.findOne({ id: figshareCategoryId, source: String(crosswalk.figshareSource) }), connection);
+            if (!category) {
+                throw new vocabulary_errors_1.RelationshipBoundaryError('The Figshare category does not belong to the crosswalk source');
+            }
+        }
+        /**
+         * Promote the working revision to the approved revision. AppConfig keeps its stable
+         * crosswalkId; publishing immediately follows the newly approved revision.
+         */
+        async approveCrosswalk(crosswalkId, revision, ctx) {
+            const crosswalk = await this.requireCrosswalk(crosswalkId, ctx.brandId);
+            if (Number(revision) !== Number(crosswalk.workingRevision)) {
+                throw new vocabulary_errors_1.CrosswalkRevisionError();
+            }
+            const mappings = await FigshareVocabularyCrosswalkMapping.find({
+                crosswalk: String(crosswalk.id),
+                revision: Number(crosswalk.workingRevision)
+            });
+            const approvable = mappings.filter((mapping) => mapping.status !== 'rejected');
+            if (approvable.length === 0) {
+                throw new vocabulary_errors_1.CatalogueInvalidError('A crosswalk revision must contain at least one mapping before it can be approved');
+            }
+            const approvedAt = this.nowIso();
+            return (0, TransactionUtils_1.runWithOptionalTransaction)(this.getDatastore(), async (connection) => {
+                for (const mapping of approvable) {
+                    await this.assertMappingOwnership(crosswalk, String(mapping.localEntry), String(mapping.figshareCategory), connection);
+                    if (mapping.status === 'approved') {
+                        continue;
+                    }
+                    await this.runQuery(FigshareVocabularyCrosswalkMapping.updateOne({ id: String(mapping.id) }).set({
+                        status: 'approved',
+                        approvedAt,
+                        approvedBy: ctx.userId
+                    }), connection);
+                }
+                await this.runQuery(FigshareVocabularyCrosswalk.updateOne({ id: String(crosswalk.id) }).set({
+                    status: 'approved',
+                    approvedRevision: Number(crosswalk.workingRevision),
+                    approvedAt,
+                    approvedBy: ctx.userId,
+                    updatedBy: ctx.userId
+                }), connection);
+                const refreshed = await this.runQuery(FigshareVocabularyCrosswalk.findOne({ id: String(crosswalk.id) }), connection);
+                return this.describeCrosswalk(refreshed ?? crosswalk);
+            }, {
+                logger: sails.log,
+                unsupportedAdapterWarning: 'Transactions are not supported by this datastore adapter. Falling back to non-transactional crosswalk approval.'
+            });
+        }
+        /**
+         * Collect the dotted paths of every crosswalk binding in a config that selects
+         * `crosswalkId`. A crosswalk can now be referenced by any binding, not just the
+         * categories one, so the whole config tree has to be walked.
+         */
+        collectCrosswalkBindings(node, crosswalkId, pathSegments, found) {
+            if (node == null || typeof node !== 'object') {
+                return;
+            }
+            if (Array.isArray(node)) {
+                node.forEach((item, index) => this.collectCrosswalkBindings(item, crosswalkId, [...pathSegments, String(index)], found));
+                return;
+            }
+            const candidate = node;
+            if (candidate.kind === 'crosswalk' && String(candidate.crosswalkId ?? '') === crosswalkId) {
+                found.push({
+                    bindingPath: pathSegments.join('.'),
+                    outputs: candidate.outputs == null ? undefined : String(candidate.outputs),
+                    sourceVocabularyId: candidate.sourceVocabularyId == null ? undefined : String(candidate.sourceVocabularyId)
+                });
+            }
+            for (const [key, value] of Object.entries(candidate)) {
+                this.collectCrosswalkBindings(value, crosswalkId, [...pathSegments, key], found);
+            }
+        }
+        /** Report the Figshare publishing bindings that select this crosswalk. */
+        async getCrosswalkUsage(crosswalkId, ctx) {
+            const crosswalk = await this.requireCrosswalk(crosswalkId, ctx.brandId);
+            const appConfigService = sails.services?.appconfigservice;
+            const brandName = this.resolveBrandName(ctx.brandId);
+            const brandConfig = appConfigService?.getAppConfigurationForBrand?.(brandName);
+            const figsharePublishing = brandConfig?.figsharePublishing;
+            const found = [];
+            this.collectCrosswalkBindings(figsharePublishing, String(crosswalk.id), [], found);
+            return found.map((binding) => ({
+                brandName,
+                configKey: 'figsharePublishing',
+                bindingPath: binding.bindingPath,
+                outputs: binding.outputs,
+                sourceVocabularyId: binding.sourceVocabularyId
+            }));
+        }
+        /** Draft crosswalks are deleted; approved ones archive to protect AppConfig references. */
+        async deleteCrosswalk(crosswalkId, ctx) {
+            const crosswalk = await this.requireCrosswalk(crosswalkId, ctx.brandId);
+            const usage = await this.getCrosswalkUsage(crosswalkId, ctx);
+            if (usage.length > 0) {
+                throw new vocabulary_errors_1.RelationshipBoundaryError('This crosswalk is selected by a Figshare publishing configuration. Remove or replace the reference first.');
+            }
+            if (crosswalk.status === 'approved') {
+                await FigshareVocabularyCrosswalk.updateOne({ id: String(crosswalk.id) }).set({
+                    status: 'archived',
+                    updatedBy: ctx.userId
+                });
+                return;
+            }
+            await FigshareVocabularyCrosswalkMapping.destroy({ crosswalk: String(crosswalk.id) });
+            await FigshareVocabularyCrosswalk.destroyOne({ id: String(crosswalk.id) });
+        }
+        // ── Publishing resolution ─────────────────────────────────────────
+        /**
+         * Resolve record codes to the Figshare categories they map to through the
+         * approved revision of a crosswalk. Working revisions are never consulted.
+         *
+         * Shared by every output mode: the caller decides whether to emit the numeric
+         * category ID, the mirrored label, or the Figshare source ID.
+         */
+        async resolveCrosswalkTargets(input) {
+            const crosswalk = await this.requireCrosswalk(String(input?.crosswalkId ?? ''), String(input?.brandId ?? ''));
+            if (crosswalk.status !== 'approved' || crosswalk.approvedRevision == null) {
+                throw new vocabulary_errors_1.RelationshipBoundaryError('The configured Figshare crosswalk has no approved revision');
+            }
+            const sourceVocabularyId = String(input?.sourceVocabularyId ?? '').trim();
+            if (!sourceVocabularyId || String(crosswalk.localVocabulary) !== sourceVocabularyId) {
+                throw new vocabulary_errors_1.RelationshipBoundaryError('The configured Figshare crosswalk maps a different local vocabulary');
+            }
+            const source = await FigshareVocabularySource.findOne({
+                id: String(crosswalk.figshareSource),
+                branding: String(input.brandId)
+            });
+            if (!source || source.archived === true) {
+                throw new vocabulary_errors_1.RelationshipBoundaryError('The Figshare source behind the configured crosswalk is unavailable');
+            }
+            const codes = Array.from(new Set((input?.codes ?? []).map((code) => (0, categories_1.normalizeCategoryCode)(code)).filter((code) => code !== '')));
+            if (codes.length === 0) {
+                return { normalizedCodes: [], matches: [], unresolvedCodes: [], historicalTargets: [] };
+            }
+            const entries = await VocabularyEntry.find({ vocabulary: sourceVocabularyId });
+            const entryByCode = new Map();
+            for (const entry of entries) {
+                const valueCode = (0, categories_1.normalizeCategoryCode)(entry.valueLower ?? entry.value);
+                if (valueCode !== '' && !entryByCode.has(valueCode)) {
+                    entryByCode.set(valueCode, entry);
+                }
+                const identifierCode = (0, categories_1.normalizeCategoryCode)(entry.identifier);
+                if (identifierCode !== '' && !entryByCode.has(identifierCode)) {
+                    entryByCode.set(identifierCode, entry);
+                }
+            }
+            const unresolvedCodes = [];
+            const matchedEntryIdsByCode = new Map();
+            for (const code of codes) {
+                const entry = entryByCode.get(code);
+                if (!entry) {
+                    unresolvedCodes.push(code);
+                    continue;
+                }
+                matchedEntryIdsByCode.set(code, String(entry.id));
+            }
+            if (matchedEntryIdsByCode.size === 0) {
+                return { normalizedCodes: codes, matches: [], unresolvedCodes, historicalTargets: [] };
+            }
+            const mappings = await FigshareVocabularyCrosswalkMapping.find({
+                crosswalk: String(crosswalk.id),
+                revision: Number(crosswalk.approvedRevision),
+                status: 'approved',
+                localEntry: Array.from(new Set(matchedEntryIdsByCode.values()))
+            });
+            if (mappings.length === 0) {
+                return {
+                    normalizedCodes: codes,
+                    matches: [],
+                    unresolvedCodes: [...unresolvedCodes, ...matchedEntryIdsByCode.keys()],
+                    historicalTargets: []
+                };
+            }
+            const categories = await FigshareVocabularyCategory.find({
+                id: Array.from(new Set(mappings.map((mapping) => String(mapping.figshareCategory))))
+            });
+            const categoryById = new Map(categories.map((category) => [String(category.id), category]));
+            const mappingsByEntryId = new Map();
+            for (const mapping of mappings) {
+                const entryId = String(mapping.localEntry);
+                const bucket = mappingsByEntryId.get(entryId);
+                if (bucket) {
+                    bucket.push(mapping);
+                }
+                else {
+                    mappingsByEntryId.set(entryId, [mapping]);
+                }
+            }
+            // Walk in code order so every output mode returns a deterministic sequence
+            // that follows the record's own ordering.
+            const matches = [];
+            const historicalTargets = [];
+            for (const [code, entryId] of matchedEntryIdsByCode) {
+                let resolved = false;
+                for (const mapping of mappingsByEntryId.get(entryId) ?? []) {
+                    const category = categoryById.get(String(mapping.figshareCategory));
+                    if (!category) {
+                        continue;
+                    }
+                    resolved = true;
+                    if (category.historical === true) {
+                        historicalTargets.push({ code, categoryId: category.categoryId, sourceId: category.sourceId });
+                        continue;
+                    }
+                    matches.push({ code, category });
+                }
+                if (!resolved) {
+                    unresolvedCodes.push(code);
+                }
+            }
+            return { normalizedCodes: codes, matches, unresolvedCodes, historicalTargets };
+        }
+        /**
+         * Resolve record category codes to numeric Figshare category IDs. Retained as
+         * the stable narrow surface over {@link resolveCrosswalkValues}.
+         */
+        async resolveCategories(input) {
+            const resolution = await this.resolveCrosswalkTargets(input);
+            const categoryIds = new Set(resolution.matches.map((match) => match.category.categoryId));
+            return {
+                categoryIds: Array.from(categoryIds).sort((left, right) => left - right),
+                unresolvedCodes: resolution.unresolvedCodes,
+                historicalTargets: resolution.historicalTargets
+            };
+        }
+        /**
+         * Resolve record codes through a crosswalk into the values a publishing binding
+         * asks for. Historical targets are excluded from `values` in every mode and
+         * reported separately so the caller can decide whether they are fatal.
+         */
+        async resolveCrosswalkValues(input) {
+            const outputs = input?.outputs || 'categoryId';
+            const resolution = await this.resolveCrosswalkTargets(input);
+            const base = {
+                normalizedCodes: resolution.normalizedCodes,
+                unresolvedCodes: resolution.unresolvedCodes,
+                historicalTargets: resolution.historicalTargets
+            };
+            if (outputs === 'categoryId') {
+                const categoryIds = new Set(resolution.matches.map((match) => match.category.categoryId));
+                return { ...base, values: Array.from(categoryIds).sort((left, right) => left - right) };
+            }
+            if (outputs === 'sourceId') {
+                return { ...base, values: Array.from(new Set(resolution.matches.map((match) => match.category.sourceId))) };
+            }
+            // Labels live on the mirrored VocabularyEntry, not on the category row.
+            const entryIds = Array.from(new Set(resolution.matches.map((match) => String(match.category.entry))));
+            const entries = entryIds.length === 0
+                ? []
+                : await VocabularyEntry.find({ id: entryIds });
+            const labelByEntryId = new Map(entries.map((entry) => [String(entry.id), entry.label]));
+            const labels = new Set();
+            for (const match of resolution.matches) {
+                const label = String(labelByEntryId.get(String(match.category.entry)) ?? '').trim();
+                if (label !== '') {
+                    labels.add(label);
+                    continue;
+                }
+                // The mapping resolved; only the display label is missing. Falling back to
+                // the source ID keeps the value usable rather than silently dropping it.
+                sails.log.warn(`Figshare crosswalk ${input.crosswalkId}: category ${match.category.sourceId} has no mirrored label, using its source ID`);
+                labels.add(match.category.sourceId);
+            }
+            return { ...base, values: Array.from(labels) };
+        }
+        // ── Bootstrap data ────────────────────────────────────────────────
+        getBootstrapDataPath() {
+            const configuredPath = lodash_1.default.get(sails.config, 'bootstrap.bootstrapDataPath', DEFAULT_BOOTSTRAP_DATA_PATH);
+            return path.resolve(String(configuredPath), 'vocabularies');
+        }
+        /** Overridable seam so unit tests can drive bootstrapData() without touching disk. */
+        getBootstrapFileOps() {
+            return fs;
+        }
+        resolveDefaultBrandingId() {
+            const brandingService = sails.services?.brandingservice;
+            const defaultBrand = brandingService?.getDefault?.();
+            if (defaultBrand && typeof defaultBrand === 'object') {
+                const brand = defaultBrand;
+                const id = brand.id ?? brand._id;
+                if (id != null && String(id).trim() !== '') {
+                    return String(id).trim();
+                }
+            }
+            return '';
+        }
+        /**
+         * Declaratively import Figshare taxonomies listed in
+         * `<bootstrapDataPath>/vocabularies/figshare-imports.json` during the Sails lift.
+         *
+         * Each item produces a read-only mirror, an editable local clone, and an approved
+         * identity crosswalk - the state a fresh environment needs for Figshare publishing to
+         * resolve categories without an administrator visiting the admin UI.
+         *
+         * Idempotent: an item whose FigshareVocabularySource already exists is skipped, so a
+         * restart never re-syncs or forks admin-curated crosswalks. Nothing here throws - a
+         * bootstrap importer must not be able to fail the lift.
+         */
+        async bootstrapData() {
+            if (lodash_1.default.get(sails.config, 'vocab.bootstrapFigshareImports') === false) {
+                sails.log.verbose('Skipping Figshare vocabulary bootstrap imports (disabled)');
+                return;
+            }
+            const filePath = path.join(this.getBootstrapDataPath(), FIGSHARE_IMPORTS_FILE);
+            let parsed = null;
+            try {
+                const content = await this.getBootstrapFileOps().readFile(filePath, 'utf8');
+                parsed = JSON.parse(content);
+            }
+            catch (error) {
+                const ioError = error;
+                if (ioError?.code === 'ENOENT') {
+                    sails.log.verbose(`Figshare vocabulary bootstrap file not found: ${filePath}`);
+                    return;
+                }
+                sails.log.error(`Failed to read Figshare vocabulary bootstrap file: ${FIGSHARE_IMPORTS_FILE}`, error);
+                return;
+            }
+            if (!Array.isArray(parsed?.imports)) {
+                sails.log.error(`Invalid Figshare imports format in bootstrap file: ${FIGSHARE_IMPORTS_FILE}`);
+                return;
+            }
+            const imports = parsed.imports;
+            if (imports.length === 0) {
+                return;
+            }
+            const brandId = this.resolveDefaultBrandingId();
+            if (!brandId) {
+                sails.log.error('Unable to resolve default branding for Figshare vocabulary bootstrap data');
+                return;
+            }
+            // Most deployments have no Figshare configuration at all; resolveClient() would throw
+            // a transport error on every lift, so check first and skip quietly instead.
+            if ((0, config_1.resolveFigshareVocabularyConfig)(this.resolveBrandName(brandId)) == null) {
+                sails.log.verbose('Skipping Figshare vocabulary bootstrap imports: Figshare is not configured for the default brand');
+                return;
+            }
+            const ctx = { brandId, userId: BOOTSTRAP_ACTOR };
+            for (const item of imports) {
+                await this.processBootstrapImport(item, ctx);
+            }
+        }
+        async processBootstrapImport(item, ctx) {
+            const scope = String(item?.scope ?? '').trim().toLowerCase();
+            const taxonomyId = String(item?.taxonomyId ?? '').trim();
+            const localCloneName = String(item?.localCloneName ?? '').trim();
+            const label = `${scope || '?'}:${taxonomyId || '?'}`;
+            if (scope !== 'public' && scope !== 'account') {
+                sails.log.error(`Skipping Figshare bootstrap import with invalid scope '${item?.scope}' (expected 'public' or 'account')`);
+                return;
+            }
+            if (!taxonomyId) {
+                sails.log.error('Skipping Figshare bootstrap import with missing taxonomyId');
+                return;
+            }
+            if (!localCloneName) {
+                sails.log.error(`Skipping Figshare bootstrap import with missing localCloneName: ${label}`);
+                return;
+            }
+            const existing = await FigshareVocabularySource.findOne({
+                branding: ctx.brandId,
+                scope,
+                taxonomyId
+            });
+            if (existing) {
+                sails.log.verbose(`Skipping existing Figshare bootstrap import: ${label}`);
+                return;
+            }
+            try {
+                await (0, PromiseUtils_1.promiseWithTimeout)(this.runBootstrapImport({ scope, taxonomyId, localCloneName, item }, ctx), FIGSHARE_IMPORT_TIMEOUT_MS, `Figshare vocabulary import ${label}`);
+                sails.log.verbose(`Imported Figshare bootstrap vocabulary: ${label}`);
+            }
+            catch (error) {
+                sails.log.error(`Failed Figshare bootstrap import: ${label}`, error);
+            }
+        }
+        async runBootstrapImport(input, ctx) {
+            const localCloneSlug = String(input.item?.localCloneSlug ?? '').trim();
+            const preview = await this.createPreview({
+                scope: input.scope,
+                taxonomyId: input.taxonomyId,
+                createLocalClone: true,
+                localCloneName: input.localCloneName,
+                localCloneSlug: localCloneSlug || undefined
+            }, ctx);
+            // Read the run row directly rather than paging getPreview(), which caps at
+            // MAX_PAGE_SIZE per page - a real taxonomy has thousands of categories. In clone
+            // mode every proposal is an identity match and preselected.
+            const run = await FigshareVocabularySyncRun.findOne({ id: preview.runId });
+            const proposals = (run?.proposals ?? []);
+            const approvedProposalIds = proposals
+                .filter((proposal) => proposal.preselected)
+                .map((proposal) => proposal.proposalId);
+            const result = await this.applyPreview(preview.runId, {
+                remoteHash: preview.remoteHash,
+                approvedProposalIds
+            }, ctx);
+            const crosswalkId = String(result.crosswalkId ?? '');
+            if (!crosswalkId) {
+                throw new Error('Figshare bootstrap import did not produce a crosswalk');
+            }
+            const requestedName = String(input.item?.crosswalkName ?? '').trim();
+            if (requestedName) {
+                // { branding, name } is a unique index, so probe before renaming.
+                const name = await this.uniqueCrosswalkName(requestedName, ctx.brandId);
+                await FigshareVocabularyCrosswalk.updateOne({ id: crosswalkId }).set({
+                    name,
+                    updatedBy: ctx.userId
+                });
+            }
+            // Mapping edges are written as 'proposed' and resolveCategories() refuses any
+            // crosswalk without an approved revision - approving here is what makes the
+            // bootstrapped crosswalk usable for publishing.
+            await this.approveCrosswalk(crosswalkId, Number(result.crosswalkRevision ?? 1), ctx);
+        }
+    }
+    Services.FigshareVocabularyService = FigshareVocabularyService;
+})(Services || (exports.Services = Services = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FigshareVocabularyService.js","sourceRoot":"","sources":["../../src/services/FigshareVocabularyService.ts"],"names":[],"mappings":"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"}