primitive-admin 1.1.0-alpha.9 → 1.2.0-alpha.0

package/dist/src/lib/codegen-shared/resolveCodegenSourceDir.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Shared source-directory resolution for the CLI codegen commands
+ * (`workflows codegen` #1442, `databases codegen` #814, `databases schema
+ * generate` #666, issue #1510).
+ *
+ * Each of them reads a set of `*.toml` schemas out of one synced sub-directory
+ * (`workflows/`, `database-type-configs/`) and renders `*.generated.ts` beside
+ * them. It used to take four branches to say which directory that was: a
+ * `--dir` override, the resolved environment, an `--app`-alone fallback, and —
+ * when none of those answered — a SCAN of every `primitive/<env>/<subdir>` that resolved
+ * if exactly one environment happened to have the directory. The scan is how
+ * `PRIMITIVE_ENV=dev workflows codegen` could generate from the `alpha` TOML,
+ * and how two codegen commands in one run could read two different
+ * environments.
+ *
+ * There is one branch now (#3154, intent criterion 4): the sub-directory of
+ * the environment's own tree. `resolveSyncDir()` refuses rather than guesses,
+ * so an ambiguous project, an unknown `--env` and no project at all each reach
+ * the user as themselves.
+ *
+ * Design notes that survive:
+ *   - Throw plain `Error`s; the calling commands keep their existing
+ *     `error(); process.exit(1)` convention (they catch at the boundary). A
+ *     `PrimitiveEnvError` from the resolver is an Error too, and its message is
+ *     already the one the user needs.
+ *   - Do NOT use `resolveAppId()` — it is auth-oriented, and codegen is
+ *     offline.
+ */
+export interface ResolveCodegenSourceDirArgs {
+    /** The synced sub-directory to resolve, e.g. "workflows" or "database-type-configs". */
+    subdir: string;
+}
+/**
+ * The single source directory a codegen command reads its `*.toml` schemas
+ * from. Throws with a user-facing message when the environment cannot be
+ * resolved or the directory is not there.
+ */
+export declare function resolveCodegenSourceDir(args: ResolveCodegenSourceDirArgs): string;

package/dist/src/lib/codegen-shared/resolveCodegenSourceDir.js

@@ -0,0 +1,46 @@
+/**
+ * Shared source-directory resolution for the CLI codegen commands
+ * (`workflows codegen` #1442, `databases codegen` #814, `databases schema
+ * generate` #666, issue #1510).
+ *
+ * Each of them reads a set of `*.toml` schemas out of one synced sub-directory
+ * (`workflows/`, `database-type-configs/`) and renders `*.generated.ts` beside
+ * them. It used to take four branches to say which directory that was: a
+ * `--dir` override, the resolved environment, an `--app`-alone fallback, and —
+ * when none of those answered — a SCAN of every `primitive/<env>/<subdir>` that resolved
+ * if exactly one environment happened to have the directory. The scan is how
+ * `PRIMITIVE_ENV=dev workflows codegen` could generate from the `alpha` TOML,
+ * and how two codegen commands in one run could read two different
+ * environments.
+ *
+ * There is one branch now (#3154, intent criterion 4): the sub-directory of
+ * the environment's own tree. `resolveSyncDir()` refuses rather than guesses,
+ * so an ambiguous project, an unknown `--env` and no project at all each reach
+ * the user as themselves.
+ *
+ * Design notes that survive:
+ *   - Throw plain `Error`s; the calling commands keep their existing
+ *     `error(); process.exit(1)` convention (they catch at the boundary). A
+ *     `PrimitiveEnvError` from the resolver is an Error too, and its message is
+ *     already the one the user needs.
+ *   - Do NOT use `resolveAppId()` — it is auth-oriented, and codegen is
+ *     offline.
+ */
+import { existsSync } from "fs";
+import { join } from "path";
+import { resolveSyncDir } from "../sync-paths.js";
+/**
+ * The single source directory a codegen command reads its `*.toml` schemas
+ * from. Throws with a user-facing message when the environment cannot be
+ * resolved or the directory is not there.
+ */
+export function resolveCodegenSourceDir(args) {
+    const { subdir } = args;
+    const dir = join(resolveSyncDir(), subdir);
+    if (!existsSync(dir)) {
+        throw new Error(`No ${subdir}/ directory in ${dir}. Run \`primitive config pull\` first, ` +
+            `or select another environment with --env <name>.`);
+    }
+    return dir;
+}
+//# sourceMappingURL=resolveCodegenSourceDir.js.map

package/dist/src/lib/codegen-shared/resolveCodegenSourceDir.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveCodegenSourceDir.js","sourceRoot":"","sources":["../../../../src/lib/codegen-shared/resolveCodegenSourceDir.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,IAAI,CAAC;AAChC,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAOlD;;;;GAIG;AACH,MAAM,UAAU,uBAAuB,CAAC,IAAiC;IACvE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACxB,MAAM,GAAG,GAAG,IAAI,CAAC,cAAc,EAAE,EAAE,MAAM,CAAC,CAAC;IAC3C,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CACb,MAAM,MAAM,kBAAkB,GAAG,yCAAyC;YACxE,kDAAkD,CACrD,CAAC;IACJ,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/src/lib/collection-export.d.ts

@@ -0,0 +1,212 @@
+/**
+ * The `collections.json` artifact, and the decisions an import makes from it
+ * (#3643).
+ *
+ * `documents export-all` / `documents import` carry Yjs state, blobs,
+ * permissions and aliases, but nothing about collections: which exist, what
+ * each contains, who its members are and at what level, its group grants, and
+ * who owns it. This module is the half of `collections export` /
+ * `collections import` that needs no server — the file's shape, the plan the
+ * import builds from it, the comparisons that plan rests on, and the exit
+ * rule — so each is checkable on its own, as `document-ingest-rows` and
+ * `snapshot-build-rows` are for their commands.
+ *
+ * The one thing that does NOT live here is resolution: which userId an email
+ * answers to, whether a document exists, whether a group exists. Those are
+ * reads against a real server, they are the facts the plan is built from, and
+ * the command performs them and hands the answers in.
+ */
+/** The only file version this CLI reads or writes. */
+export declare const COLLECTION_EXPORT_VERSION = 1;
+/** Its name inside an export directory, beside `manifest.json`. */
+export declare const COLLECTION_EXPORT_FILENAME = "collections.json";
+export type CollectionPermission = "reader" | "read-write";
+export interface ExportedOwner {
+    /** The SOURCE app's userId. Meaningful in the target only for a same-app import. */
+    userId: string;
+    /** Present when the source server could resolve it; the only cross-app identity. */
+    email?: string;
+}
+export interface ExportedMember extends ExportedOwner {
+    permission: CollectionPermission;
+}
+export interface ExportedGroupGrant {
+    groupType: string;
+    groupId: string;
+    permission: CollectionPermission;
+}
+export interface ExportedCollectionDocument {
+    documentId: string;
+    addedAt?: string | null;
+}
+export interface ExportedCollection {
+    collectionId: string;
+    name: string;
+    description: string | null;
+    collectionType: string | null;
+    createdAt: string | null;
+    owner: ExportedOwner | null;
+    documents: ExportedCollectionDocument[];
+    members: ExportedMember[];
+    groups: ExportedGroupGrant[];
+}
+export interface CollectionExportFile {
+    version: number;
+    exportedAt: string;
+    sourceAppId: string;
+    collectionCount: number;
+    collections: ExportedCollection[];
+}
+/** A file as the import reads it: the file, plus what reading it counted. */
+export interface ReadCollectionExportFile extends CollectionExportFile {
+    /**
+     * How many collections in the file carry a non-empty `contextId`. Files
+     * exported before the platform removed the field (#3926) still have one; it
+     * is read only to be counted, so the import can say once that it is not
+     * carried across. Never written.
+     */
+    legacyContextIdCount: number;
+}
+/**
+ * Resolve the `<path>` an import was given to the file it must read.
+ *
+ * Both forms work: an export DIRECTORY (the one `documents export-all` also
+ * wrote into) and the file itself.
+ */
+export declare function resolveCollectionExportPath(inputPath: string): string;
+/**
+ * Read and validate `collections.json`.
+ *
+ * Every refusal here happens BEFORE any request: a file this CLI cannot read
+ * is not a reason to start writing collections into the target app.
+ */
+export declare function readCollectionExportFile(inputPath: string): ReadCollectionExportFile;
+export type CollectionImportAction = "create" | "merge" | "skip" | "refused";
+/** Which part of a collection a per-item problem is about. */
+export type CollectionProblemKind = "owner" | "collection" | "document" | "member" | "group";
+export interface CollectionImportProblem {
+    sourceCollectionId: string;
+    name: string;
+    kind: CollectionProblemKind;
+    /** The offending identity: a userId, an email, a documentId, `type/id`. */
+    id: string;
+    reason: string;
+}
+/** The target collection a name match found, as far as compatibility cares. */
+export interface ExistingTargetCollection {
+    collectionId: string;
+    createdBy: string;
+    collectionType: string | null;
+}
+export interface CollectionResolution {
+    /** The userId the owner resolved to in the TARGET app, or null. */
+    ownerUserId: string | null;
+    /** Why the owner could not be resolved — becomes the refusal's reason. */
+    ownerReason?: string;
+    /** The ONE target collection carrying this exact name, if any. */
+    existing?: ExistingTargetCollection | null;
+    /**
+     * Every target collection id carrying this exact name, when more than one
+     * does. A name is a label, not an identity (#3925), so matching by name
+     * cannot choose between them.
+     */
+    ambiguousTargetIds?: string[] | null;
+    /** The source id of an earlier collection in the same file with this name. */
+    duplicateOfSourceId?: string | null;
+}
+export interface CollectionPlanRow {
+    sourceCollectionId: string;
+    name: string;
+    action: CollectionImportAction;
+    /** Why it was refused or skipped. Absent for `create`/`merge`. */
+    reason?: string;
+    /** Where it lands: known up front only for a `merge`. */
+    targetCollectionId?: string;
+    /** The resolved owner, for a `create`. */
+    ownerUserId?: string;
+    /** A refusal that must also be REPORTED as a problem carries it here. */
+    problem?: Omit<CollectionImportProblem, "sourceCollectionId" | "name">;
+}
+/**
+ * Which of `createdBy` and `collectionType` a name match differs on — the
+ * fields the server will never let an update change (`collections-controller.ts`
+ * rejects a type change; `createdBy` is immutable), so a difference cannot be
+ * merged away (F2). A `contextId` an older file still carries is not compared:
+ * the platform removed the field (#3926), so it is no difference at all.
+ *
+ * Returns null when the match is compatible.
+ */
+export declare function incompatibleField(collection: Pick<ExportedCollection, "collectionType">, existing: ExistingTargetCollection, ownerUserId: string): "owner" | "collectionType" | null;
+/** What to do about one recorded group grant, given the target's grants. */
+export type GrantDisposition = "grant" | "already-applied" | "update";
+/**
+ * Compare a recorded grant with the target's.
+ *
+ * A grant already at the recorded level counts as applied without a write. A
+ * grant at a DIFFERENT level is sent: #3163 recomputes each document's
+ * materialized `DocumentGroupPermission` from its live sources on every
+ * collection-wide change, so the new level reaches what the group's members can
+ * actually do. Before that it did not — `materializeDGP` left an existing row
+ * alone once the collection was one of its sources — which is why the import
+ * used to report such a grant instead of changing it (F3).
+ */
+export declare function grantDisposition(wanted: ExportedGroupGrant, targetGrants: ExportedGroupGrant[]): GrantDisposition;
+/** The line a level change is announced with, named from and to. */
+export declare function grantUpdateLine(groupLabel: string, existingPermission: string, wantedPermission: string): string;
+/**
+ * What a server refusal reads as in a per-item problem.
+ *
+ * The prose alone is not enough to act on. `COLLECTION_FANOUT_LIMIT` is the
+ * case that matters here: past `COLLECTION_GROUP_FANOUT_MAX` documents the
+ * server refuses a collection-wide group change whole (#3163), and the remedy —
+ * split the collection, or grant its documents one at a time — is nothing like
+ * the remedy for a 404 group. Carrying the code makes the two tellable apart by
+ * a script as well as by a reader.
+ */
+export declare function serverReason(err: any): string;
+/**
+ * Decide what happens to one collection, from the facts the resolve phase read.
+ *
+ * Nothing here talks to a server: every input is already an answer.
+ */
+export declare function planCollection(collection: ExportedCollection, resolution: CollectionResolution, options: {
+    overwrite: boolean;
+}): CollectionPlanRow;
+/**
+ * The source ids of earlier same-named collections, keyed by source id.
+ *
+ * The FIRST collection with a name is the one that may land; every later one
+ * maps to it here and is refused.
+ */
+export declare function duplicateNameSources(collections: ExportedCollection[]): Map<string, string>;
+/**
+ * The target app's collections grouped by name, in listing order.
+ *
+ * A name is a label, not an identity (#3925), so one name may map to several
+ * collections; the resolve phase passes a lone match on as `existing` and more
+ * than one as `ambiguousTargetIds`.
+ */
+export declare function groupTargetsByName(rows: Array<{
+    collectionId: string;
+    name: string;
+    createdBy: string;
+    collectionType?: string | null;
+}>): Map<string, ExistingTargetCollection[]>;
+export interface CollectionImportSummary {
+    created: number;
+    merged: number;
+    skipped: number;
+    refused: number;
+    groupsGranted: number;
+    membersAdded: number;
+    documentsAdded: number;
+}
+export declare function emptyImportSummary(): CollectionImportSummary;
+/**
+ * The exit rule, in one place: 1 when any per-item problem was reported.
+ *
+ * A skip for a name collision is NOT a problem — it is the documented way to
+ * re-run an import without `--overwrite`. A refusal is, because something the
+ * operator asked for did not happen.
+ */
+export declare function importExitCode(problems: CollectionImportProblem[]): number;

package/dist/src/lib/collection-export.js

@@ -0,0 +1,288 @@
+/**
+ * The `collections.json` artifact, and the decisions an import makes from it
+ * (#3643).
+ *
+ * `documents export-all` / `documents import` carry Yjs state, blobs,
+ * permissions and aliases, but nothing about collections: which exist, what
+ * each contains, who its members are and at what level, its group grants, and
+ * who owns it. This module is the half of `collections export` /
+ * `collections import` that needs no server — the file's shape, the plan the
+ * import builds from it, the comparisons that plan rests on, and the exit
+ * rule — so each is checkable on its own, as `document-ingest-rows` and
+ * `snapshot-build-rows` are for their commands.
+ *
+ * The one thing that does NOT live here is resolution: which userId an email
+ * answers to, whether a document exists, whether a group exists. Those are
+ * reads against a real server, they are the facts the plan is built from, and
+ * the command performs them and hands the answers in.
+ */
+import fs from "node:fs";
+import path from "node:path";
+/** The only file version this CLI reads or writes. */
+export const COLLECTION_EXPORT_VERSION = 1;
+/** Its name inside an export directory, beside `manifest.json`. */
+export const COLLECTION_EXPORT_FILENAME = "collections.json";
+/**
+ * Resolve the `<path>` an import was given to the file it must read.
+ *
+ * Both forms work: an export DIRECTORY (the one `documents export-all` also
+ * wrote into) and the file itself.
+ */
+export function resolveCollectionExportPath(inputPath) {
+    if (fs.existsSync(inputPath) && fs.statSync(inputPath).isDirectory()) {
+        return path.join(inputPath, COLLECTION_EXPORT_FILENAME);
+    }
+    return inputPath;
+}
+/**
+ * Read and validate `collections.json`.
+ *
+ * Every refusal here happens BEFORE any request: a file this CLI cannot read
+ * is not a reason to start writing collections into the target app.
+ */
+export function readCollectionExportFile(inputPath) {
+    const filePath = resolveCollectionExportPath(inputPath);
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`No ${COLLECTION_EXPORT_FILENAME} found at ${filePath}. Point the ` +
+            `import at an export directory holding one, or at the file itself.`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    }
+    catch (err) {
+        throw new Error(`${filePath} is not valid JSON: ${err.message}`);
+    }
+    if (parsed?.version !== COLLECTION_EXPORT_VERSION) {
+        throw new Error(`${filePath} declares version ${JSON.stringify(parsed?.version)}; ` +
+            `this CLI reads version ${COLLECTION_EXPORT_VERSION} only.`);
+    }
+    const collections = Array.isArray(parsed.collections) ? parsed.collections : [];
+    const legacyContextIdCount = collections.filter((c) => typeof c?.contextId === "string" && c.contextId !== "").length;
+    return {
+        version: parsed.version,
+        exportedAt: String(parsed.exportedAt ?? ""),
+        sourceAppId: String(parsed.sourceAppId ?? ""),
+        collectionCount: Number(parsed.collectionCount ?? collections.length),
+        collections,
+        legacyContextIdCount,
+    };
+}
+/**
+ * Which of `createdBy` and `collectionType` a name match differs on — the
+ * fields the server will never let an update change (`collections-controller.ts`
+ * rejects a type change; `createdBy` is immutable), so a difference cannot be
+ * merged away (F2). A `contextId` an older file still carries is not compared:
+ * the platform removed the field (#3926), so it is no difference at all.
+ *
+ * Returns null when the match is compatible.
+ */
+export function incompatibleField(collection, existing, ownerUserId) {
+    if (existing.createdBy !== ownerUserId)
+        return "owner";
+    // The server defaults an unset type to "default", so the file's null and the
+    // target's "default" are the same collection type, not a difference.
+    const wanted = collection.collectionType || "default";
+    if ((existing.collectionType || "default") !== wanted)
+        return "collectionType";
+    return null;
+}
+/**
+ * Compare a recorded grant with the target's.
+ *
+ * A grant already at the recorded level counts as applied without a write. A
+ * grant at a DIFFERENT level is sent: #3163 recomputes each document's
+ * materialized `DocumentGroupPermission` from its live sources on every
+ * collection-wide change, so the new level reaches what the group's members can
+ * actually do. Before that it did not — `materializeDGP` left an existing row
+ * alone once the collection was one of its sources — which is why the import
+ * used to report such a grant instead of changing it (F3).
+ */
+export function grantDisposition(wanted, targetGrants) {
+    const existing = targetGrants.find((g) => g.groupType === wanted.groupType && g.groupId === wanted.groupId);
+    if (!existing)
+        return "grant";
+    return existing.permission === wanted.permission
+        ? "already-applied"
+        : "update";
+}
+/** The line a level change is announced with, named from and to. */
+export function grantUpdateLine(groupLabel, existingPermission, wantedPermission) {
+    return (`${groupLabel}: ${existingPermission} → ${wantedPermission} ` +
+        `(the level the export records)`);
+}
+/**
+ * What a server refusal reads as in a per-item problem.
+ *
+ * The prose alone is not enough to act on. `COLLECTION_FANOUT_LIMIT` is the
+ * case that matters here: past `COLLECTION_GROUP_FANOUT_MAX` documents the
+ * server refuses a collection-wide group change whole (#3163), and the remedy —
+ * split the collection, or grant its documents one at a time — is nothing like
+ * the remedy for a 404 group. Carrying the code makes the two tellable apart by
+ * a script as well as by a reader.
+ */
+export function serverReason(err) {
+    const message = err?.message ?? String(err);
+    const code = typeof err?.code === "string" ? err.code : null;
+    return code ? `${message} (${code})` : message;
+}
+/**
+ * Decide what happens to one collection, from the facts the resolve phase read.
+ *
+ * Nothing here talks to a server: every input is already an answer.
+ */
+export function planCollection(collection, resolution, options) {
+    const base = {
+        sourceCollectionId: collection.collectionId,
+        name: collection.name,
+    };
+    // The import matches by name, so two collections in one file that share one
+    // could not be told apart on a re-run. The second is refused before
+    // anything is written, naming both source ids.
+    if (resolution.duplicateOfSourceId) {
+        return {
+            ...base,
+            action: "refused",
+            reason: `the export lists two collections named "${collection.name}" ` +
+                `(${resolution.duplicateOfSourceId} and ${collection.collectionId}); ` +
+                `the import matches by name, so the file can describe only one ` +
+                `collection per name. Rename one in the export and re-run.`,
+            problem: {
+                kind: "collection",
+                id: collection.collectionId,
+                reason: `duplicate name "${collection.name}" in the export file`,
+            },
+        };
+    }
+    // Two or more target collections carry the name (#3925): the file could mean
+    // any of them, so neither a skip nor a merge is safe. Refused whatever
+    // --overwrite says, and ahead of the owner — one problem per collection.
+    const ambiguous = resolution.ambiguousTargetIds ?? [];
+    if (ambiguous.length > 1) {
+        const reason = `${ambiguous.length} collections named "${collection.name}" exist in ` +
+            `the target (${ambiguous.join(", ")}), and the import matches by name, ` +
+            `so it cannot tell which one the file means`;
+        return {
+            ...base,
+            action: "refused",
+            reason: `${reason}. Rename or delete all but one of them in the target, or ` +
+                `rename the collection in the export, and re-run.`,
+            problem: { kind: "collection", id: collection.name, reason },
+        };
+    }
+    if (!resolution.ownerUserId) {
+        const reason = resolution.ownerReason ??
+            `its owner could not be resolved in the target app`;
+        return {
+            ...base,
+            action: "refused",
+            reason: `${reason}. Pass --owner <userId-or-email> to give every collection in this run an owner that exists here.`,
+            problem: {
+                kind: "owner",
+                id: collection.owner?.email || collection.owner?.userId || "(none)",
+                reason,
+            },
+        };
+    }
+    const existing = resolution.existing ?? null;
+    if (!existing) {
+        return {
+            ...base,
+            action: "create",
+            ownerUserId: resolution.ownerUserId,
+        };
+    }
+    // A name match is checked for compatibility WHETHER OR NOT --overwrite was
+    // given: none of these fields can be changed after creation, so an
+    // incompatible match can never become the collection the file describes, and
+    // reporting it under --dry-run is the point (F2).
+    const field = incompatibleField(collection, existing, resolution.ownerUserId);
+    if (field) {
+        const reason = `a collection named "${collection.name}" already exists in the target ` +
+            `(${existing.collectionId}) with a different ${field}, which cannot be ` +
+            `changed after creation`;
+        return {
+            ...base,
+            action: "refused",
+            targetCollectionId: existing.collectionId,
+            reason: `${reason}. Delete or rename it, or rename the collection in the export.`,
+            problem: { kind: "collection", id: existing.collectionId, reason },
+        };
+    }
+    if (!options.overwrite) {
+        return {
+            ...base,
+            action: "skip",
+            targetCollectionId: existing.collectionId,
+            reason: `already exists (use --overwrite to merge into ${existing.collectionId})`,
+        };
+    }
+    return {
+        ...base,
+        action: "merge",
+        targetCollectionId: existing.collectionId,
+        ownerUserId: resolution.ownerUserId,
+    };
+}
+/**
+ * The source ids of earlier same-named collections, keyed by source id.
+ *
+ * The FIRST collection with a name is the one that may land; every later one
+ * maps to it here and is refused.
+ */
+export function duplicateNameSources(collections) {
+    const firstByName = new Map();
+    const duplicates = new Map();
+    for (const collection of collections) {
+        const seen = firstByName.get(collection.name);
+        if (seen) {
+            duplicates.set(collection.collectionId, seen);
+        }
+        else {
+            firstByName.set(collection.name, collection.collectionId);
+        }
+    }
+    return duplicates;
+}
+/**
+ * The target app's collections grouped by name, in listing order.
+ *
+ * A name is a label, not an identity (#3925), so one name may map to several
+ * collections; the resolve phase passes a lone match on as `existing` and more
+ * than one as `ambiguousTargetIds`.
+ */
+export function groupTargetsByName(rows) {
+    const byName = new Map();
+    for (const row of rows) {
+        const matches = byName.get(row.name) ?? [];
+        matches.push({
+            collectionId: row.collectionId,
+            createdBy: row.createdBy,
+            collectionType: row.collectionType ?? null,
+        });
+        byName.set(row.name, matches);
+    }
+    return byName;
+}
+export function emptyImportSummary() {
+    return {
+        created: 0,
+        merged: 0,
+        skipped: 0,
+        refused: 0,
+        groupsGranted: 0,
+        membersAdded: 0,
+        documentsAdded: 0,
+    };
+}
+/**
+ * The exit rule, in one place: 1 when any per-item problem was reported.
+ *
+ * A skip for a name collision is NOT a problem — it is the documented way to
+ * re-run an import without `--overwrite`. A refusal is, because something the
+ * operator asked for did not happen.
+ */
+export function importExitCode(problems) {
+    return problems.length > 0 ? 1 : 0;
+}
+//# sourceMappingURL=collection-export.js.map

package/dist/src/lib/collection-export.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection-export.js","sourceRoot":"","sources":["../../../src/lib/collection-export.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/config-json-field.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Emitting a `type: "json"` field (a JSON Schema, a provider-options blob) as
+ * TOML — the rule `config pull` writes every such field through.
+ *
+ * Issue #1446 wrote it for workflows and prompts inside `sync.ts`; #3317 moved
+ * it here because `serializeFunction` lives in its own module and needed the
+ * same rule rather than a second, subtly different copy of it. A function's
+ * schemas are stored as JSON STRINGS on the row, so the module that could not
+ * reach this one emitted nothing at all for them, and the comparison read the
+ * server as holding no schema.
+ */
+/**
+ * The TOML value for one `type: "json"` field, or `undefined` when the record
+ * holds none (the key is then omitted).
+ *
+ * The parsed value is emitted as a native table whenever it round-trips
+ * faithfully (`canEmitNative === null`), falling back to the JSON string only
+ * for the values TOML silently drops (`null` / `undefined` anywhere inside).
+ * The empty object `{}` is a real, distinct value (for a schema: "accepts
+ * anything") and emits as an empty table, so it survives a pull → push cycle
+ * instead of being cleared server-side.
+ *
+ * The sponsor-approved decision is to always move to native aggressively — no
+ * form preservation — so this does not consult the existing file's form.
+ *
+ * `subject` names the object in the fallback warning, e.g. `Workflow 'greet'`.
+ */
+export declare function serializeJsonField(value: any, fieldName: string, subject: string, log: (message: string) => void): any;