@stonecrop/schema 0.31.0 → 0.32.0

package/dist/converter-CLwduvT_.js

@@ -0,0 +1,2102 @@
+import { t as flattenFields } from "./flatten-Bx2cfvw3.js";
+import { z } from "zod";
+import { buildClientSchema, buildSchema, isEnumType, isListType, isNamedType, isNonNullType, isObjectType, isScalarType } from "graphql";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
+	if (typeof require !== "undefined") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+});
+//#endregion
+//#region src/table.ts
+/**
+* JSON-safe view configuration for table fields in doctype authoring.
+*
+* This is the authoring-time subset of `@stonecrop/atable`'s `TableConfig`. It covers
+* the view discriminator and structural options that can be expressed in static JSON.
+* `rowActions` (which requires function-typed handlers) stays in the runtime `TableConfig`.
+*
+* @public
+*/
+var TableViewConfig = z.object({
+	/** The table view type */
+	view: z.enum([
+		"list",
+		"uncounted",
+		"list-expansion",
+		"tree",
+		"gantt",
+		"tree-gantt"
+	]).optional(),
+	/** Allow the table to use the full width of its container */
+	fullWidth: z.boolean().optional(),
+	/** Default expansion state for tree views */
+	defaultTreeExpansion: z.enum([
+		"root",
+		"branch",
+		"leaf"
+	]).optional(),
+	/** Enable dependency graph connections for Gantt views */
+	dependencyGraph: z.boolean().optional()
+}).meta({
+	title: "TableViewConfig",
+	description: "JSON-safe view configuration for table fields in doctype authoring"
+});
+//#endregion
+//#region src/field.ts
+/**
+* Field options - flexible bag for type-specific configuration.
+*
+* Usage:
+* - Select: array of choices (["Draft", "Submitted", "Cancelled"])
+* - Select with badges: \{ choices: [...], badges: \{ Open: "warning", ... \} \} or bare map
+* - Decimal: config object (\{ precision: 10, scale: 2 \})
+* - Code: config object (\{ language: "python" \})
+*
+* Deliberately *not* a bare string: a string once meant "link target", which made the value's
+* shape encode its meaning. That job belongs to `ValueField.doctype`, leaving this a plain
+* choices-or-config bag.
+*
+* @public
+*/
+var FieldOptions = z.union([z.array(z.string()), z.record(z.string(), z.unknown())]).meta({
+	title: "FieldOptions",
+	description: "Field options - flexible bag for type-specific configuration"
+});
+/**
+* Validation configuration for form fields
+* @public
+*/
+var FieldValidation = z.looseObject({ 
+/** Error message to display when validation fails */
+errorMessage: z.string() }).meta({
+	title: "FieldValidation",
+	description: "Validation configuration for form fields"
+});
+/**
+* Which of the three field shapes an entry has, read from the entry's own structure.
+*
+* The single definition of that question. It had three copies before this — the parser's
+* `injectKind`, {@link stripFieldKind}'s agreement check, and the docbuilder's own
+* `isValueField` in another package — each free to drift, and drift here re-types a field rather
+* than throwing: a value field read as a fieldset loses its column, a fieldset read as a value
+* field loses every child.
+*
+* Deliberately **shape-only**: a declared `kind` is ignored. Two callers depend on that. The
+* stripper compares this against the declaration to decide whether removing it is lossless, which
+* it cannot do if this honours it. The docbuilder reads raw JSON off disk and classifies entries to
+* decide which to render as editable rows — and `kind` is Stonecrop's own discriminant, not
+* something a doctype author writes, so a tool reading a file has no business consulting it.
+*
+* `injectKind` is the one place a declaration still wins, and only to leave an already-parsed
+* object untouched on its way back through.
+*
+* @param field - a field entry, authored or parsed
+* @returns the kind its shape implies
+* @public
+*/
+function inferFieldKind(field) {
+	if (typeof field !== "object" || field === null || Array.isArray(field)) return "field";
+	if ("schema" in field) return "fieldset";
+	if ("columns" in field) return "table";
+	return "field";
+}
+/**
+* Infers the `kind` discriminant from the structural properties of a raw field
+* object, then injects it if absent. This allows authored JSON to omit `kind`
+* entirely — a `schema` key means fieldset, `columns` means table, anything else
+* is a value field.
+*
+* Rules (applied in order):
+*   has `schema`  → fieldset
+*   has `columns` → table
+*   otherwise     → field (value-holding scalar or link)
+*
+* Objects that already carry `kind` pass through unchanged (backward-compatible).
+*
+* Single-node only. Zod applies this at every level of the discriminated union (via the
+* `z.lazy` in the fieldset schema), so nested fieldset children are normalized during a
+* parse. Callers that bypass Zod — notably `Doctype.fromObject` — must use the exported
+* {@link normalizeFieldKind} instead, which replicates that recursion.
+*/
+function injectKind(data) {
+	if (typeof data !== "object" || data === null || Array.isArray(data)) return data;
+	const obj = data;
+	if ("kind" in obj) return data;
+	return {
+		kind: inferFieldKind(obj),
+		...obj
+	};
+}
+/**
+* Recursively injects the `kind` discriminant into a raw field object and, for fieldsets,
+* into each of its nested `schema` children — mirroring exactly what Zod's `preprocess`
+* does at every level of the discriminated union.
+*
+* Table `columns` are {@link ColumnSchema} entries, not `DoctypeField`s, so they are left
+* untouched — the Zod table schema validates them with a plain passthrough and never injects
+* `kind` there either.
+*
+* Needed because `Doctype.fromObject` constructs a Doctype without running Zod, yet the
+* registry's `resolveFields` gates link and fieldset handling on `field.kind`. Without this,
+* a JSON-authored link resolves to a flat scalar and a fieldset's children are dropped.
+*
+* @public
+*/
+function normalizeFieldKind(field) {
+	const injected = injectKind(field);
+	if (typeof injected !== "object" || injected === null) return injected;
+	const obj = injected;
+	if (obj.kind === "fieldset" && Array.isArray(obj.schema)) return {
+		...obj,
+		schema: obj.schema.map(normalizeFieldKind)
+	};
+	return injected;
+}
+/**
+* Remove the `kind` discriminant from a field, recursing into a fieldset's children.
+*
+* The outbound half of the boundary {@link normalizeFieldKind} owns inbound. `kind` is a
+* discriminated-union tag the parser synthesizes, not something an author writes, so nothing that
+* *writes* a doctype should put it on disk — the generator and the docbuilder's save both call
+* this. Without it the two round-trip asymmetrically: every save adds a key the file never had.
+*
+* Strips only when `injectKind` would restore exactly what was removed. A fieldset carrying no
+* `schema` re-infers as a plain field, so its `kind` is kept rather than silently re-typing the
+* document; `DoctypeMeta` requires `schema` on a fieldset, so that shape is already invalid and
+* belongs to the load gate, not here.
+*
+* Table `columns` are {@link ColumnSchema} entries rather than `DoctypeField`s and never carry an
+* injected `kind`, so they are passed through untouched — the same asymmetry `injectKind` has.
+*
+* @param field - a field object, as held in memory after parsing
+* @returns the field without `kind`, safe to serialize
+* @public
+*/
+function stripFieldKind(field) {
+	if (typeof field !== "object" || field === null || Array.isArray(field)) return field;
+	const obj = field;
+	if (obj.kind !== void 0 && obj.kind !== inferFieldKind(obj)) return field;
+	const { kind: _kind, ...rest } = obj;
+	if (Array.isArray(rest.schema)) return {
+		...rest,
+		schema: rest.schema.map(stripFieldKind)
+	};
+	return rest;
+}
+/**
+* The field properties a `source: 'introspected'` marker freezes — the ones the database owns.
+*
+* This is the single definition of the identity set. The docbuilder greys these inputs on an
+* introspected field, and the converter's merge refuses to rewrite them. Stating it twice is how
+* the two drift, so both read this constant.
+*
+* Everything absent from this list is author-owned, `component` most importantly: it chooses the
+* widget, which is an authoring decision the database has no opinion about.
+*
+* @public
+*/
+var INTROSPECTED_IDENTITY_PROPS = [
+	"fieldname",
+	"primaryKey",
+	"required",
+	"options",
+	"cardinality",
+	"doctype"
+];
+/**
+* Find the field a doctype marks as its primary key, or `undefined` when none is marked.
+*
+* This is the single definition of "which field identifies a record". Both sides depend on it:
+* the middleware builds the SQL identity predicate from it, and the client resolves a record's
+* route/store key from it. Call this; never re-derive the rule at the call site, or the two will
+* drift and the client will key records by a column the server never queried.
+*
+* Two deliberate rules, both matching the shape `primaryKey` actually has:
+* - Fieldset children are **included**, via {@link flattenFields}. A fieldset is layout, not
+*   scope: its children are fields of the doctype with columns of their own, which is why the
+*   adapter's SELECT already descends and why `getDisplayField` does too. Scanning top level only
+*   did not *refuse* a nested declaration — it ignored one, so an author marked identity and
+*   nothing honoured it and nothing said so.
+* - The **first** match in document order wins. Identity is single-valued by design — a doctype
+*   describes the API surface, and mapping a composite database key onto one identity there is the
+*   adapter's job — so a doctype declaring several is malformed rather than composite.
+*   `DoctypeMeta` rejects that at the load gate; this stays total for callers holding fields that
+*   never went through it.
+*
+* @param fields - the doctype's fields; fieldset children are descended into
+* @returns the primary-key field, or `undefined` for a PK-less doctype
+* @public
+*/
+function getPrimaryKeyField(fields) {
+	return flattenFields(fields).find((f) => f.kind === "field" && Boolean(f.primaryKey));
+}
+/**
+* Resolve the field a doctype nominates as its display text, or `undefined` when the nomination
+* does not name a readable column.
+*
+* This is the single definition of "is this a usable `displayField`". Both sides depend on it:
+* `DoctypeMeta` refuses a bad nomination at the load gate, and the adapter builds a SELECT from
+* the field it returns. Call this; never re-derive the rule, or the gate and the query will
+* disagree about which nominations are legal — which they did, in both directions at once.
+*
+* Two things disqualify a nomination, and both are the doctype saying so itself:
+* - it names no field at all, fieldset children included
+* - it names a `computed` field, which is declared precisely to state it has no column, so a
+*   SELECT built from it would reference a column the database does not have
+*
+* @param fields - the doctype's top-level fields
+* @param displayField - the nominated fieldname
+* @returns the nominated field, or `undefined` when it is not a readable column
+* @public
+*/
+function getDisplayField(fields, displayField) {
+	if (!displayField) return void 0;
+	return flattenFields(fields).find((f) => f.kind === "field" && !f.computed && f.fieldname === displayField);
+}
+/**
+* The name of the field a record is identified by: the declared `primaryKey`, or `id` when the
+* doctype declares none.
+*
+* The `id` fallback is load-bearing, not defensive — a surrogate-key doctype carries an `id`
+* column and marks no primary key, so "nothing declared" means `id`, not "no identity".
+*
+* This exists because that one-line rule had been restated at four sites — the client's
+* `Doctype.recordIdField`, both nuxt hosts' `recordLookupField`, and the Postgres adapter — and
+* the fourth had omitted the fallback, so a doctype the client keyed by `id` was one the adapter
+* could not look up at all. Call this; a fifth restatement is how they diverge again.
+*
+* The returned name is not guaranteed to be a declared field: a doctype that declares no
+* `primaryKey` and no `id` yields `'id'` regardless. An adapter that must build a SQL predicate
+* from it has to confirm the field exists and say so when it does not, because selecting a column
+* the doctype never declared returns nothing rather than failing.
+*
+* @param fields - the doctype's top-level fields
+* @returns the identifying fieldname
+* @public
+*/
+function getRecordIdField(fields) {
+	return getPrimaryKeyField(fields)?.fieldname ?? "id";
+}
+/**
+* Resolve a record's identity value using the doctype's declared primary key.
+*
+* Falls back to `record.id` when the doctype declares no `primaryKey`. That fallback is
+* load-bearing, not defensive: surrogate-key doctypes carry an `id` column and never mark a
+* primary key, and PostGraphile renames a single-column `id` PK to `rowId` — so the declared
+* field and `id` are both real sources, in that order.
+*
+* @param fields - the doctype's top-level fields
+* @param record - the record to read the identity from
+* @returns the identity as a string, or `undefined` when neither source yields a usable value
+* @public
+*/
+function getRecordIdentity(fields, record) {
+	const pkField = getPrimaryKeyField(fields);
+	const candidates = pkField ? [record[pkField.fieldname], record.id] : [record.id];
+	for (const value of candidates) {
+		if (typeof value === "number") return String(value);
+		if (typeof value === "string" && value !== "") return value;
+	}
+}
+function createDoctypeFieldSchemas() {
+	const ValueFieldSchema = z.object({
+		kind: z.literal("field"),
+		fieldname: z.string().min(1),
+		component: z.string().min(1),
+		primaryKey: z.boolean().optional(),
+		computed: z.boolean().optional(),
+		language: z.string().optional(),
+		doctype: z.string().min(1).optional(),
+		label: z.string().optional(),
+		width: z.string().optional(),
+		height: z.string().optional(),
+		align: z.enum([
+			"left",
+			"center",
+			"right",
+			"start",
+			"end"
+		]).optional(),
+		edit: z.boolean().optional(),
+		mask: z.string().optional(),
+		format: z.string().optional(),
+		mode: z.enum([
+			"edit",
+			"read",
+			"display"
+		]).optional(),
+		options: FieldOptions.optional(),
+		required: z.boolean().optional(),
+		readOnly: z.boolean().optional(),
+		hidden: z.boolean().optional(),
+		default: z.unknown().optional(),
+		validation: FieldValidation.optional(),
+		cardinality: z.enum([
+			"atMostOne",
+			"one",
+			"noneOrMany",
+			"atLeastOne"
+		]).optional(),
+		source: z.literal("introspected").optional()
+	}).meta({ title: "ValueField" });
+	const TableFieldSchema = z.object({
+		kind: z.literal("table"),
+		fieldname: z.string().min(1),
+		component: z.string().optional(),
+		label: z.string().optional(),
+		columns: z.array(z.object({ fieldname: z.string().min(1) }).passthrough()),
+		config: TableViewConfig.optional(),
+		mode: z.enum([
+			"edit",
+			"read",
+			"display"
+		]).optional()
+	}).meta({ title: "TableField" });
+	let DoctypeFieldSchema = z.never();
+	const FieldsetFieldSchema = z.object({
+		kind: z.literal("fieldset"),
+		fieldname: z.string().min(1),
+		component: z.string().optional(),
+		label: z.string().optional(),
+		collapsible: z.boolean().optional(),
+		mode: z.enum([
+			"edit",
+			"read",
+			"display"
+		]).optional(),
+		schema: z.lazy(() => DoctypeFieldSchema.array())
+	}).meta({ title: "FieldsetField" });
+	const rawUnion = z.discriminatedUnion("kind", [
+		ValueFieldSchema,
+		FieldsetFieldSchema,
+		TableFieldSchema
+	]);
+	DoctypeFieldSchema = z.preprocess(injectKind, rawUnion);
+	return {
+		ValueFieldSchema,
+		TableFieldSchema,
+		FieldsetFieldSchema,
+		DoctypeFieldSchema
+	};
+}
+var schemas = createDoctypeFieldSchemas();
+/**
+* Zod runtime validation schema for ValueField.
+* @public
+*/
+var ValueFieldSchema = schemas.ValueFieldSchema;
+/**
+* Zod runtime validation schema for FieldsetField.
+* Recursive — FieldsetField.schema is validated against DoctypeFieldSchema.
+* @public
+*/
+var FieldsetFieldSchema = schemas.FieldsetFieldSchema;
+/**
+* Zod runtime validation schema for TableField.
+* @public
+*/
+var TableFieldSchema = schemas.TableFieldSchema;
+/**
+* Zod runtime validation schema for the DoctypeField discriminated union.
+* Validates all three field variants: `'field'`, `'fieldset'`, `'table'`.
+* @public
+*/
+var DoctypeFieldSchema = schemas.DoctypeFieldSchema;
+//#endregion
+//#region src/naming.ts
+/**
+* Naming Convention Utilities
+* Converts between various naming conventions (snake_case, camelCase, PascalCase, kebab-case)
+* @packageDocumentation
+*/
+/**
+* Converts snake_case to camelCase
+* @param snakeCase - Snake case string
+* @returns Camel case string
+* @public
+* @example
+* ```typescript
+* snakeToCamel('user_email') // 'userEmail'
+* snakeToCamel('created_at') // 'createdAt'
+* ```
+*/
+function snakeToCamel(snakeCase) {
+	return snakeCase.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+/**
+* Converts camelCase to snake_case
+* @param camelCase - Camel case string
+* @returns Snake case string
+* @public
+* @example
+* ```typescript
+* camelToSnake('userEmail') // 'user_email'
+* camelToSnake('createdAt') // 'created_at'
+* ```
+*/
+function camelToSnake(camelCase) {
+	return camelCase.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+/**
+* Converts snake_case to Title Case label
+* @param snakeCase - Snake case string
+* @returns Title case label
+* @public
+* @example
+* ```typescript
+* snakeToLabel('user_email') // 'User Email'
+* snakeToLabel('first_name') // 'First Name'
+* ```
+*/
+function snakeToLabel(snakeCase) {
+	return snakeCase.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+}
+/**
+* Converts camelCase to Title Case label
+* @param camelCase - Camel case string
+* @returns Title case label
+* @public
+* @example
+* ```typescript
+* camelToLabel('userEmail') // 'User Email'
+* camelToLabel('firstName') // 'First Name'
+* ```
+*/
+function camelToLabel(camelCase) {
+	const withSpaces = camelCase.replace(/([A-Z])/g, " $1").trim();
+	return withSpaces.charAt(0).toUpperCase() + withSpaces.slice(1);
+}
+/**
+* Convert table name to PascalCase doctype name
+* @param tableName - SQL table name (snake_case)
+* @returns PascalCase name
+* @public
+*/
+function toPascalCase(tableName) {
+	return tableName.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+/**
+* Convert to kebab-case slug
+* @param name - Name to convert
+* @returns kebab-case slug
+* @public
+*/
+function toSlug(name) {
+	return name.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+/**
+* Convert PascalCase to snake_case (e.g., for deriving table names from type names)
+* @param pascal - PascalCase string
+* @returns snake_case string
+* @public
+* @example
+* ```typescript
+* pascalToSnake('SalesOrder') // 'sales_order'
+* pascalToSnake('SalesOrderItem') // 'sales_order_item'
+* ```
+*/
+function pascalToSnake(pascal) {
+	return pascal.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+}
+//#endregion
+//#region src/doctype.ts
+/**
+* Cardinality for relationship links.
+* @public
+*/
+var Cardinality = z.enum([
+	"atMostOne",
+	"one",
+	"noneOrMany",
+	"atLeastOne"
+]).meta({
+	title: "Cardinality",
+	description: "Cardinality for relationship links between doctypes"
+});
+/**
+* Sync fetch strategy - data is fetched in the initial query.
+* @public
+*/
+var SyncFetch = z.object({
+	/** Fetch method type */
+	method: z.literal("sync"),
+	/** Optional limit on number of records to fetch */
+	limit: z.number().int().positive().optional()
+}).meta({
+	title: "SyncFetch",
+	description: "Sync fetch strategy - data is fetched in the initial query"
+});
+/**
+* Lazy fetch strategy - data is fetched on demand in a separate query.
+* @public
+*/
+var LazyFetch = z.object({ 
+/** Fetch method type */
+method: z.literal("lazy") }).meta({
+	title: "LazyFetch",
+	description: "Lazy fetch strategy - data is fetched on demand in a separate query"
+});
+/**
+* Custom fetch strategy - uses a custom handler function.
+* @public
+*/
+var CustomFetch = z.object({
+	/** Fetch method type */
+	method: z.literal("custom"),
+	/** Serialized handler function to invoke */
+	handler: z.string()
+}).meta({
+	title: "CustomFetch",
+	description: "Custom fetch strategy - uses a custom handler function"
+});
+/**
+* Fetch strategy for link data loading.
+* - sync: fetched in the initial query
+* - lazy: fetched on demand in a separate query
+* - custom: uses a custom handler function
+* @public
+*/
+var FetchStrategy = z.discriminatedUnion("method", [
+	SyncFetch,
+	LazyFetch,
+	CustomFetch
+]).meta({
+	title: "FetchStrategy",
+	description: "Fetch strategy for link data loading"
+});
+/**
+* Link declaration - describes a relationship from one doctype to another.
+* @public
+*/
+var LinkDeclaration = z.object({
+	/** Target doctype slug */
+	target: z.string().min(1),
+	/** Cardinality of the relationship */
+	cardinality: Cardinality,
+	/** Backlink fieldname on the target doctype that points back to this link */
+	backlink: z.string().optional(),
+	/** Override default rendering component (AForm for 1:1, ATable for 1:many) */
+	component: z.string().optional(),
+	/** Fieldname of the corresponding Link field in the fields array */
+	fieldname: z.string().min(1).optional(),
+	/** Fetch strategy for loading nested data */
+	fetch: FetchStrategy.optional(),
+	/** Whether to block workflow actions until nested data is loaded (default: true) */
+	blockWorkflows: z.boolean().optional()
+}).meta({
+	title: "LinkDeclaration",
+	description: "Declares a relationship from one doctype to another"
+});
+/**
+* Action definition within a workflow
+* @public
+*/
+var ActionDefinition = z.object({
+	/** Display label for the action */
+	label: z.string().min(1),
+	/** Fields that must have values before action can execute */
+	requiredFields: z.array(z.string()).optional(),
+	/** Workflow states where this action is available */
+	allowedStates: z.array(z.string()).optional(),
+	/** The state the record transitions to after this action executes */
+	nextState: z.string().optional(),
+	/** True for stateless command actions with no workflow effect at all (print, email, etc.) */
+	stateless: z.boolean().optional(),
+	/**
+	* True for an internal self-transition: the action runs within the current state without
+	* advancing the workflow (e.g. `save`, which mutates record data but stays put). Scoped by
+	* `allowedStates`, rendered as a self-loop in the graph, and has no `nextState`. Distinct from
+	* `stateless` (which has no workflow presence at all): a self-transition is graph-owned and,
+	* unlike a stateless command, persists record data on dispatch.
+	*/
+	selfTransition: z.boolean().optional(),
+	/** JS function body stored as a string; executed client-side via AsyncFunction with injected API surface */
+	clientHandler: z.string().optional()
+}).meta({
+	title: "ActionDefinition",
+	description: "Action definition within a workflow"
+});
+/**
+* Reactive field-validation trigger — advisory, client-side only.
+*
+* A Trigger is a docbuilder-authored validator: when any field in `on` is edited, its
+* `clientHandler` runs (client-side, no rollback) and may flag a field inline to block save
+* in the UI. It is deliberately a **sibling** to {@link (ActionDefinition:type)}, not a member of it —
+* a reactive validator is not a user-invoked action, so it lives in the `triggers` map on
+* {@link (WorkflowMeta:type)} and never appears to action readers (transition/command dropdowns, the FSM graph).
+*
+* The two bindings are independent: `on` is the fire-set (which fields' edits run it), while the
+* `setError(field, msg)` call inside `clientHandler` chooses which field displays the error.
+* @public
+*/
+var TriggerDefinition = z.object({
+	/** Optional display label; the map key is the trigger's identity */
+	label: z.string().optional(),
+	/** Fieldnames whose edits fire this trigger (fires when any listed field changes) */
+	on: z.array(z.string()),
+	/** JS function body stored as a string; run client-side with `{ record, value, setError }`. Advisory. */
+	clientHandler: z.string()
+}).meta({
+	title: "TriggerDefinition",
+	description: "Reactive field-validation trigger — advisory client-side"
+});
+/**
+* Whether a workflow action may run from `currentState`.
+*
+* Single source of truth for the "is this action available here" rule, shared by
+* the frontend (`getAvailableTransitions`) and the server-side dispatch guard so
+* the two can never disagree. Empty or absent `allowedStates` means the action is
+* available in ALL states — a plain `allowedStates.includes(currentState)` would
+* wrongly block such actions everywhere.
+*
+* @public
+*/
+function isActionAllowedInState(action, currentState) {
+	const allowedStates = action.allowedStates;
+	if (!allowedStates || allowedStates.length === 0) return true;
+	return allowedStates.includes(currentState);
+}
+/**
+* DocBuilder graph layout — node positions for the workflow-state graph, keyed by state name.
+* Pure authoring view-state: persisted in the doctype JSON so an author's manual arrangement
+* survives reloads, but — exactly like {@link (WorkflowMeta:type)}'s `triggers` — it is client-only
+* and never mirrored into the runtime GraphQL SDL (see the WorkflowMeta type in the host SDLs, which
+* expose only `states`/`actions`). The shape mirrors VueFlow's node fields; `position` is the node's
+* canvas coordinate and `targetPosition`/`sourcePosition` are the handle sides.
+* @public
+*/
+var WorkflowLayout = z.record(z.string(), z.object({
+	position: z.object({
+		x: z.number(),
+		y: z.number()
+	}).optional(),
+	targetPosition: z.enum([
+		"left",
+		"top",
+		"right",
+		"bottom"
+	]).optional(),
+	sourcePosition: z.enum([
+		"left",
+		"top",
+		"right",
+		"bottom"
+	]).optional()
+}));
+/**
+* Workflow metadata - states and actions for a doctype
+* @public
+*/
+var WorkflowMeta = z.object({
+	/** List of workflow states */
+	states: z.array(z.string()).optional(),
+	/** Actions available in this workflow */
+	actions: z.record(z.string(), ActionDefinition).optional(),
+	/** Reactive field-validation triggers (advisory, client-side), keyed by trigger name */
+	triggers: z.record(z.string(), TriggerDefinition).optional(),
+	/**
+	* DocBuilder node positions keyed by state name — authoring view-state. Persisted here so a
+	* doctype author's manual graph arrangement survives reloads; like `triggers`, it is client-only
+	* and never enters the runtime GraphQL SDL. See {@link (WorkflowLayout:variable)}.
+	*/
+	layout: WorkflowLayout.optional()
+}).meta({
+	title: "WorkflowMeta",
+	description: "Workflow metadata - states and actions for a doctype"
+});
+/**
+* Doctype metadata - complete definition of a doctype
+* @public
+*/
+var DoctypeMeta = z.object({
+	/** Display name of the doctype */
+	name: z.string().min(1),
+	/** URL-friendly slug (kebab-case) */
+	slug: z.string().min(1).optional(),
+	/**
+	* Field on this doctype used when displaying a reference to one of its records.
+	* When a record elsewhere holds an inline foreign key to this doctype, the middleware
+	* returns that field as `{ id, displayText }`, reading `displayText` from this field.
+	*/
+	displayField: z.string().min(1).optional(),
+	/**
+	* URL path this doctype registers at, written literally — `/order` for a collection,
+	* `/order/:id` for a record. Absent means the doctype has no page of its own, which is the
+	* common case: a child table is reached inside its parent, never at a URL.
+	*
+	* A path rather than a segment because the record parameter has to be somewhere, and a host
+	* that reads a bare segment has to know which kind of doctype it is holding to decide where
+	* to put it. Writing it out means nothing downstream re-derives it.
+	*/
+	route: z.string().startsWith("/").optional(),
+	/** Field definitions (a link field is one carrying `doctype`) */
+	fields: z.array(DoctypeFieldSchema),
+	/** Relationship links to other doctypes */
+	links: z.record(z.string(), LinkDeclaration).optional(),
+	/** Workflow configuration */
+	workflow: WorkflowMeta.optional(),
+	/** Parent doctype for inheritance */
+	inherits: z.string().optional()
+}).meta({
+	title: "DoctypeMeta",
+	description: "Doctype metadata - complete definition of a doctype"
+}).superRefine((doctype, ctx) => {
+	const declared = flattenFields(doctype.fields).filter((f) => f.kind === "field" && f.primaryKey);
+	if (declared.length > 1) ctx.addIssue({
+		code: "custom",
+		path: ["fields"],
+		message: `Doctype declares ${declared.length} primaryKey fields (${declared.map((f) => f.kind === "field" ? f.fieldname : "").join(", ")}); a record is identified by exactly one field. A composite database key is mapped to a single identity by the adapter, so a doctype never declares its parts`
+	});
+	if (doctype.displayField && !getDisplayField(doctype.fields, doctype.displayField)) {
+		const named = flattenFields(doctype.fields).find((f) => f.fieldname === doctype.displayField);
+		ctx.addIssue({
+			code: "custom",
+			path: ["displayField"],
+			message: named ? `displayField "${doctype.displayField}" names a computed field, which has no column to read a display value from` : `displayField "${doctype.displayField}" is not declared on this doctype`
+		});
+	}
+});
+/**
+* The one string a doctype is addressed by.
+*
+* A doctype carries two names — `name` (`OrderItem`) and `slug` (`order-item`) — and every registry
+* must agree on which one keys it. Three implementations had drifted apart: the adapter's registry is
+* keyed by `name` and its `getMeta` also scans for a matching `slug`, so it accepts **either**; the
+* client's registry is keyed by a slug it derives itself and accepts **only** that; and
+* `Doctype.fromObject` dropped an authored `slug` on the floor and re-derived one regardless. The
+* adapter's accepted set was therefore a strict superset of the client's, and a link target written
+* as the Name booted the server, passed its reference check, served rows over GraphQL, and was
+* silently dropped by the client — an expanding child table rendering as one empty text input, with
+* nothing logged.
+*
+* Resolving through this in both runtimes is what makes the two answers the same answer. It is the
+* derivation only; a *lookup* still belongs to whichever registry owns the corpus, because the two
+* corpora legitimately differ (a client registers lazily, and a client-only host has no adapter at
+* all).
+*
+* An authored `slug` wins over the derived one because the authored doctype is the source of truth:
+* generation verifies a file and never overwrites it, so a doctype that states its own slug means it.
+* Deriving unconditionally is what `fromObject` did, and it made an authored `slug` a silent no-op on
+* one side of the wire while the other honoured it.
+*
+* @param doctype - anything carrying a doctype's `name` and optional authored `slug`
+* @returns the canonical slug
+* @public
+*
+* @example
+* ```typescript
+* getDoctypeSlug({ name: 'OrderItem' })                      // 'order-item'
+* getDoctypeSlug({ name: 'Planner', slug: 'planner-board' }) // 'planner-board'
+* ```
+*/
+function getDoctypeSlug(doctype) {
+	return doctype.slug || toSlug(doctype.name);
+}
+/**
+* Suffix appended to a link fieldname for its pre-resolved display text in record payloads.
+*
+* @deprecated The `__display` suffix pattern is no longer used. Inline link fields are enriched
+* server-side by `@stonecrop/graphql-middleware` as `{ id, displayText }` objects on the link
+* field itself.
+* @public
+*/
+var LINK_DISPLAY_SUFFIX = "__display";
+/**
+* Build the payload key for a link field's display text (e.g. `customerId__display`).
+*
+* @deprecated The `__display` suffix pattern is no longer used. Inline link fields are enriched
+* server-side by `@stonecrop/graphql-middleware` as `{ id, displayText }` objects on the link
+* field itself.
+* @public
+*/
+function linkDisplayFieldname(fieldname) {
+	return `${fieldname}${LINK_DISPLAY_SUFFIX}`;
+}
+//#endregion
+//#region src/validation.ts
+/**
+* Validate a field definition against the DoctypeField discriminated union
+* @param data - Data to validate
+* @returns Validation result
+* @public
+*/
+function validateField(data) {
+	const result = DoctypeFieldSchema.safeParse(data);
+	if (result.success) return {
+		success: true,
+		errors: []
+	};
+	return {
+		success: false,
+		errors: result.error.issues.map((issue) => ({
+			path: issue.path,
+			message: issue.message
+		}))
+	};
+}
+/**
+* Validate a doctype definition
+* @param data - Data to validate
+* @returns Validation result
+* @public
+*/
+function validateDoctype(data) {
+	const result = DoctypeMeta.safeParse(data);
+	if (result.success) return {
+		success: true,
+		errors: []
+	};
+	return {
+		success: false,
+		errors: result.error.issues.map((issue) => ({
+			path: issue.path,
+			message: issue.message
+		}))
+	};
+}
+/**
+* Parse and validate a field, throwing on failure
+* @param data - Data to parse
+* @returns Validated DoctypeField
+* @throws ZodError if validation fails
+* @public
+*/
+function parseField(data) {
+	return DoctypeFieldSchema.parse(data);
+}
+/**
+* Parse and validate a doctype, throwing on failure
+* @param data - Data to parse
+* @returns Validated DoctypeMeta
+* @throws ZodError if validation fails
+* @public
+*/
+function parseDoctype(data) {
+	return DoctypeMeta.parse(data);
+}
+//#endregion
+//#region src/converter/scalars.ts
+/**
+* Mapping from standard GraphQL scalar types to Stonecrop field types.
+* These are defined by the GraphQL specification and are always available.
+*
+* @public
+*/
+var GQL_SCALAR_MAP = {
+	String: { component: "ATextInput" },
+	Int: { component: "ANumericInput" },
+	Float: { component: "ANumericInput" },
+	Boolean: { component: "ACheckbox" },
+	ID: { component: "ATextInput" }
+};
+/**
+* Mapping from well-known custom GraphQL scalars to Stonecrop field types.
+* These cover scalars commonly used across GraphQL servers (PostGraphile, Hasura, etc.)
+* without baking in knowledge of any specific server.
+*
+* Entries here have lower precedence than `customScalars` from options, but higher
+* precedence than unknown/unmapped scalars.
+*
+* @public
+*/
+var WELL_KNOWN_SCALARS = {
+	BigFloat: { component: "ANumericInput" },
+	BigDecimal: { component: "ANumericInput" },
+	Decimal: { component: "ANumericInput" },
+	BigInt: { component: "ANumericInput" },
+	Long: { component: "ANumericInput" },
+	UUID: { component: "ATextInput" },
+	DateTime: { component: "ADateTime" },
+	Datetime: { component: "ADateTime" },
+	Date: { component: "ADate" },
+	Time: { component: "ATextInput" },
+	Interval: { component: "ADuration" },
+	Duration: { component: "ADuration" },
+	JSON: { component: "ACodeEditor" },
+	JSONObject: { component: "ACodeEditor" },
+	JsonNode: { component: "ACodeEditor" }
+};
+/**
+* Set of scalar type names that are internal to GraphQL servers and should be skipped
+* during field conversion (they don't represent meaningful data fields).
+*
+* @public
+*/
+var INTERNAL_SCALARS = /* @__PURE__ */ new Set(["Cursor"]);
+/**
+* Build a merged scalar map from the built-in maps and user-provided custom scalars.
+* Precedence (highest to lowest): customScalars → GQL_SCALAR_MAP → WELL_KNOWN_SCALARS
+*
+* @param customScalars - User-provided scalar overrides
+* @returns Merged scalar map
+* @public
+*/
+function buildScalarMap(customScalars) {
+	const merged = { ...WELL_KNOWN_SCALARS };
+	for (const [key, value] of Object.entries(GQL_SCALAR_MAP)) merged[key] = value;
+	if (customScalars) for (const [key, value] of Object.entries(customScalars)) merged[key] = { component: value.component ?? "ATextInput" };
+	return merged;
+}
+//#endregion
+//#region src/converter/heuristics.ts
+/**
+* Default heuristics for identifying entity types and fields in a GraphQL schema.
+*
+* These heuristics work across common GraphQL servers (PostGraphile, Hasura, Apollo, etc.)
+* by detecting widely-adopted conventions like the Relay connection pattern.
+*
+* All heuristics can be overridden via the `isEntityType`, `isEntityField`, and
+* `classifyField` options in `GraphQLConversionOptions`.
+*
+* @packageDocumentation
+*/
+/**
+* Suffixes that identify synthetic/framework types generated by GraphQL servers.
+* Types ending with these suffixes are typically not entities.
+*/
+var SYNTHETIC_SUFFIXES = [
+	"Connection",
+	"Edge",
+	"Input",
+	"Patch",
+	"Payload",
+	"Condition",
+	"Filter",
+	"OrderBy",
+	"Aggregate",
+	"AggregateResult",
+	"AggregateFilter",
+	"DeleteResponse",
+	"InsertResponse",
+	"UpdateResponse",
+	"MutationResponse"
+];
+/**
+* Root operation type names that are never entities.
+*/
+var ROOT_TYPE_NAMES = /* @__PURE__ */ new Set([
+	"Query",
+	"Mutation",
+	"Subscription"
+]);
+/**
+* Default heuristic to determine if a GraphQL object type represents an entity.
+* An entity type becomes a Stonecrop doctype.
+*
+* This heuristic excludes:
+* - Introspection types (`__*`)
+* - Root operation types (`Query`, `Mutation`, `Subscription`)
+* - Types with synthetic suffixes (e.g., `*Connection`, `*Edge`, `*Input`)
+* - Types starting with `Node` interface marker (exact match only)
+*
+* @param typeName - The GraphQL type name
+* @param type - The GraphQL object type definition
+* @returns `true` if this type should become a Stonecrop doctype
+* @public
+*/
+function defaultIsEntityType(typeName, type) {
+	if (typeName.startsWith("__")) return false;
+	if (ROOT_TYPE_NAMES.has(typeName)) return false;
+	if (typeName === "Node") return false;
+	for (const suffix of SYNTHETIC_SUFFIXES) if (typeName.endsWith(suffix)) return false;
+	const fields = type.getFields();
+	if (Object.keys(fields).length === 0) return false;
+	return true;
+}
+/**
+* Fields to skip by default on entity types.
+* These are internal to GraphQL servers and don't represent semantic data.
+*
+* Relay's global object identifier is deliberately absent: which field carries it is a
+* declaration, not a name. See {@link relayNodeIdField}.
+*/
+var SKIP_FIELDS = /* @__PURE__ */ new Set(["__typename", "clientMutationId"]);
+/**
+* The name Relay's Object Identification spec gives its marker interface.
+*/
+var RELAY_NODE_INTERFACE = "Node";
+/**
+* The field carrying Relay's global object identifier on this type, or `undefined` for a type that
+* declares none.
+*
+* Read off the interface rather than matched against a list of names, because the name is a server
+* setting: PostGraphile exposes it as `nodeIdFieldName`, which is `id` under the un-overridden
+* Amber preset, `nodeId` under Stonecrop's, and whatever a foreign host chose under theirs. A
+* hardcoded name is a snapshot of one of those, and gets it wrong in both directions at once — it
+* emits an opaque identifier as a column (whose every read then fails on a column that does not
+* exist), and drops a real column that happens to share the name.
+*
+* The interface must be Relay's marker and not a domain interface that shares its name, so it has
+* to declare exactly one field, a non-null `ID`, and nothing else — anything carrying domain fields
+* is a different interface, and skipping against it would drop real columns.
+*
+* @internal
+*/
+function relayNodeIdField(type) {
+	for (const iface of type.getInterfaces()) {
+		if (iface.name !== RELAY_NODE_INTERFACE) continue;
+		const declared = Object.values(iface.getFields());
+		if (declared.length !== 1) continue;
+		const { namedType, required, isList } = unwrapType(declared[0].type);
+		if (required && !isList && namedType.name === "ID") return declared[0].name;
+	}
+}
+/**
+* Default heuristic to filter fields on entity types.
+* Skips internal fields that don't represent meaningful data.
+*
+* @param fieldName - The GraphQL field name
+* @param _field - The GraphQL field definition (unused in default implementation)
+* @param parentType - The parent entity type, whose interfaces declare its Relay identifier
+* @returns `true` if this field should be included
+* @public
+*/
+function defaultIsEntityField(fieldName, _field, parentType) {
+	if (SKIP_FIELDS.has(fieldName)) return false;
+	return fieldName !== relayNodeIdField(parentType);
+}
+/**
+* Unwrap NonNull and List wrappers from a GraphQL type, tracking nullability.
+*
+* @param type - The GraphQL output type
+* @returns The unwrapped named type, whether it's required, and whether it's a list
+* @internal
+*/
+function unwrapType(type) {
+	let required = false;
+	let isList = false;
+	let current = type;
+	if (isNonNullType(current)) {
+		required = true;
+		current = current.ofType;
+	}
+	if (isListType(current)) {
+		isList = true;
+		current = current.ofType;
+		if (isNonNullType(current)) current = current.ofType;
+	}
+	if (!isNamedType(current)) throw new Error(`Expected a named GraphQL type, got: ${String(current)}`);
+	return {
+		namedType: current,
+		required,
+		isList
+	};
+}
+/**
+* Check if a GraphQL object type looks like a Relay Connection type.
+* A connection type has an `edges` field returning a list of edge types,
+* where each edge has a `node` field.
+*
+* @param type - The GraphQL object type to check
+* @returns The node type name if this is a connection, or `undefined`
+* @internal
+*/
+function getConnectionNodeType(type) {
+	const edgesField = type.getFields()["edges"];
+	if (!edgesField) return void 0;
+	const { namedType: edgesType, isList: edgesIsList } = unwrapType(edgesField.type);
+	if (!edgesIsList || !isObjectType(edgesType)) return void 0;
+	const nodeField = edgesType.getFields()["node"];
+	if (!nodeField) return void 0;
+	const { namedType: nodeType } = unwrapType(nodeField.type);
+	if (!isObjectType(nodeType)) return void 0;
+	return nodeType.name;
+}
+/**
+* Classify a single GraphQL field into a Stonecrop field definition.
+*
+* Classification rules (in order):
+* 1. Scalar types → look up in merged scalar map
+* 2. Enum types → `Select` with enum values as options
+* 3. Object types that are entities → `Link` with slug as options
+* 4. Object types that are Connections → `Doctype` with node type slug as options
+* 5. List of entity type → `Doctype` with item type slug as options
+* 6. Anything else → `Data` with `_unmapped: true`
+*
+* @param fieldName - The GraphQL field name
+* @param field - The GraphQL field definition
+* @param entityTypes - Set of type names classified as entities
+* @param options - Conversion options (for custom scalars, unmapped meta, etc.)
+* @returns The Stonecrop field definition
+* @public
+*/
+function classifyFieldType(fieldName, field, entityTypes, options = {}) {
+	const { namedType, required, isList } = unwrapType(field.type);
+	const scalarMap = buildScalarMap(options.customScalars);
+	const base = {
+		kind: "field",
+		fieldname: fieldName,
+		label: camelToLabel(fieldName),
+		component: "ATextInput"
+	};
+	if (required) base.required = true;
+	if (isScalarType(namedType)) {
+		if (INTERNAL_SCALARS.has(namedType.name)) {
+			base._unmapped = true;
+			if (options.includeUnmappedMeta) base._graphqlType = namedType.name;
+			return base;
+		}
+		if (namedType.name === "ID") {
+			const candidateTypeName = toPascalCase(fieldName);
+			if (entityTypes.has(candidateTypeName)) {
+				base.component = "AFormLink";
+				base.doctype = toSlug(candidateTypeName);
+				return base;
+			}
+		}
+		const template = scalarMap[namedType.name];
+		if (template) base.component = template.component;
+		else {
+			base._unmapped = true;
+			if (options.includeUnmappedMeta) base._graphqlType = namedType.name;
+		}
+		return base;
+	}
+	if (isEnumType(namedType)) {
+		base.component = "ADropdown";
+		base.options = namedType.getValues().map((v) => v.name);
+		return base;
+	}
+	if (isObjectType(namedType)) {
+		if (!isList && entityTypes.has(namedType.name)) {
+			base.component = "AFormLink";
+			base.doctype = toSlug(namedType.name);
+			return base;
+		}
+		const connectionNodeTypeName = getConnectionNodeType(namedType);
+		if (connectionNodeTypeName && entityTypes.has(connectionNodeTypeName)) {
+			base.component = "ATable";
+			base._isLink = true;
+			base.doctype = toSlug(connectionNodeTypeName);
+			base.cardinality = "noneOrMany";
+			return base;
+		}
+		if (isList && entityTypes.has(namedType.name)) {
+			base.component = "ATable";
+			base._isLink = true;
+			base.doctype = toSlug(namedType.name);
+			base.cardinality = "noneOrMany";
+			return base;
+		}
+		base._unmapped = true;
+		if (options.includeUnmappedMeta) base._graphqlType = namedType.name;
+		return base;
+	}
+	base._unmapped = true;
+	if (options.includeUnmappedMeta) base._graphqlType = namedType.name;
+	return base;
+}
+//#endregion
+//#region src/converter/aggregate.ts
+var import_pluralize = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(root, pluralize) {
+		/* istanbul ignore else */
+		if (typeof __require === "function" && typeof exports === "object" && typeof module === "object") module.exports = pluralize();
+		else if (typeof define === "function" && define.amd) define(function() {
+			return pluralize();
+		});
+		else root.pluralize = pluralize();
+	})(exports, function() {
+		var pluralRules = [];
+		var singularRules = [];
+		var uncountables = {};
+		var irregularPlurals = {};
+		var irregularSingles = {};
+		/**
+		* Sanitize a pluralization rule to a usable regular expression.
+		*
+		* @param  {(RegExp|string)} rule
+		* @return {RegExp}
+		*/
+		function sanitizeRule(rule) {
+			if (typeof rule === "string") return new RegExp("^" + rule + "$", "i");
+			return rule;
+		}
+		/**
+		* Pass in a word token to produce a function that can replicate the case on
+		* another word.
+		*
+		* @param  {string}   word
+		* @param  {string}   token
+		* @return {Function}
+		*/
+		function restoreCase(word, token) {
+			if (word === token) return token;
+			if (word === word.toLowerCase()) return token.toLowerCase();
+			if (word === word.toUpperCase()) return token.toUpperCase();
+			if (word[0] === word[0].toUpperCase()) return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
+			return token.toLowerCase();
+		}
+		/**
+		* Interpolate a regexp string.
+		*
+		* @param  {string} str
+		* @param  {Array}  args
+		* @return {string}
+		*/
+		function interpolate(str, args) {
+			return str.replace(/\$(\d{1,2})/g, function(match, index) {
+				return args[index] || "";
+			});
+		}
+		/**
+		* Replace a word using a rule.
+		*
+		* @param  {string} word
+		* @param  {Array}  rule
+		* @return {string}
+		*/
+		function replace(word, rule) {
+			return word.replace(rule[0], function(match, index) {
+				var result = interpolate(rule[1], arguments);
+				if (match === "") return restoreCase(word[index - 1], result);
+				return restoreCase(match, result);
+			});
+		}
+		/**
+		* Sanitize a word by passing in the word and sanitization rules.
+		*
+		* @param  {string}   token
+		* @param  {string}   word
+		* @param  {Array}    rules
+		* @return {string}
+		*/
+		function sanitizeWord(token, word, rules) {
+			if (!token.length || uncountables.hasOwnProperty(token)) return word;
+			var len = rules.length;
+			while (len--) {
+				var rule = rules[len];
+				if (rule[0].test(word)) return replace(word, rule);
+			}
+			return word;
+		}
+		/**
+		* Replace a word with the updated word.
+		*
+		* @param  {Object}   replaceMap
+		* @param  {Object}   keepMap
+		* @param  {Array}    rules
+		* @return {Function}
+		*/
+		function replaceWord(replaceMap, keepMap, rules) {
+			return function(word) {
+				var token = word.toLowerCase();
+				if (keepMap.hasOwnProperty(token)) return restoreCase(word, token);
+				if (replaceMap.hasOwnProperty(token)) return restoreCase(word, replaceMap[token]);
+				return sanitizeWord(token, word, rules);
+			};
+		}
+		/**
+		* Check if a word is part of the map.
+		*/
+		function checkWord(replaceMap, keepMap, rules, bool) {
+			return function(word) {
+				var token = word.toLowerCase();
+				if (keepMap.hasOwnProperty(token)) return true;
+				if (replaceMap.hasOwnProperty(token)) return false;
+				return sanitizeWord(token, token, rules) === token;
+			};
+		}
+		/**
+		* Pluralize or singularize a word based on the passed in count.
+		*
+		* @param  {string}  word      The word to pluralize
+		* @param  {number}  count     How many of the word exist
+		* @param  {boolean} inclusive Whether to prefix with the number (e.g. 3 ducks)
+		* @return {string}
+		*/
+		function pluralize(word, count, inclusive) {
+			var pluralized = count === 1 ? pluralize.singular(word) : pluralize.plural(word);
+			return (inclusive ? count + " " : "") + pluralized;
+		}
+		/**
+		* Pluralize a word.
+		*
+		* @type {Function}
+		*/
+		pluralize.plural = replaceWord(irregularSingles, irregularPlurals, pluralRules);
+		/**
+		* Check if a word is plural.
+		*
+		* @type {Function}
+		*/
+		pluralize.isPlural = checkWord(irregularSingles, irregularPlurals, pluralRules);
+		/**
+		* Singularize a word.
+		*
+		* @type {Function}
+		*/
+		pluralize.singular = replaceWord(irregularPlurals, irregularSingles, singularRules);
+		/**
+		* Check if a word is singular.
+		*
+		* @type {Function}
+		*/
+		pluralize.isSingular = checkWord(irregularPlurals, irregularSingles, singularRules);
+		/**
+		* Add a pluralization rule to the collection.
+		*
+		* @param {(string|RegExp)} rule
+		* @param {string}          replacement
+		*/
+		pluralize.addPluralRule = function(rule, replacement) {
+			pluralRules.push([sanitizeRule(rule), replacement]);
+		};
+		/**
+		* Add a singularization rule to the collection.
+		*
+		* @param {(string|RegExp)} rule
+		* @param {string}          replacement
+		*/
+		pluralize.addSingularRule = function(rule, replacement) {
+			singularRules.push([sanitizeRule(rule), replacement]);
+		};
+		/**
+		* Add an uncountable word rule.
+		*
+		* @param {(string|RegExp)} word
+		*/
+		pluralize.addUncountableRule = function(word) {
+			if (typeof word === "string") {
+				uncountables[word.toLowerCase()] = true;
+				return;
+			}
+			pluralize.addPluralRule(word, "$0");
+			pluralize.addSingularRule(word, "$0");
+		};
+		/**
+		* Add an irregular word definition.
+		*
+		* @param {string} single
+		* @param {string} plural
+		*/
+		pluralize.addIrregularRule = function(single, plural) {
+			plural = plural.toLowerCase();
+			single = single.toLowerCase();
+			irregularSingles[single] = plural;
+			irregularPlurals[plural] = single;
+		};
+		/**
+		* Irregular rules.
+		*/
+		[
+			["I", "we"],
+			["me", "us"],
+			["he", "they"],
+			["she", "they"],
+			["them", "them"],
+			["myself", "ourselves"],
+			["yourself", "yourselves"],
+			["itself", "themselves"],
+			["herself", "themselves"],
+			["himself", "themselves"],
+			["themself", "themselves"],
+			["is", "are"],
+			["was", "were"],
+			["has", "have"],
+			["this", "these"],
+			["that", "those"],
+			["echo", "echoes"],
+			["dingo", "dingoes"],
+			["volcano", "volcanoes"],
+			["tornado", "tornadoes"],
+			["torpedo", "torpedoes"],
+			["genus", "genera"],
+			["viscus", "viscera"],
+			["stigma", "stigmata"],
+			["stoma", "stomata"],
+			["dogma", "dogmata"],
+			["lemma", "lemmata"],
+			["schema", "schemata"],
+			["anathema", "anathemata"],
+			["ox", "oxen"],
+			["axe", "axes"],
+			["die", "dice"],
+			["yes", "yeses"],
+			["foot", "feet"],
+			["eave", "eaves"],
+			["goose", "geese"],
+			["tooth", "teeth"],
+			["quiz", "quizzes"],
+			["human", "humans"],
+			["proof", "proofs"],
+			["carve", "carves"],
+			["valve", "valves"],
+			["looey", "looies"],
+			["thief", "thieves"],
+			["groove", "grooves"],
+			["pickaxe", "pickaxes"],
+			["passerby", "passersby"]
+		].forEach(function(rule) {
+			return pluralize.addIrregularRule(rule[0], rule[1]);
+		});
+		/**
+		* Pluralization rules.
+		*/
+		[
+			[/s?$/i, "s"],
+			[/[^\u0000-\u007F]$/i, "$0"],
+			[/([^aeiou]ese)$/i, "$1"],
+			[/(ax|test)is$/i, "$1es"],
+			[/(alias|[^aou]us|t[lm]as|gas|ris)$/i, "$1es"],
+			[/(e[mn]u)s?$/i, "$1s"],
+			[/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, "$1"],
+			[/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1i"],
+			[/(alumn|alg|vertebr)(?:a|ae)$/i, "$1ae"],
+			[/(seraph|cherub)(?:im)?$/i, "$1im"],
+			[/(her|at|gr)o$/i, "$1oes"],
+			[/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, "$1a"],
+			[/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, "$1a"],
+			[/sis$/i, "ses"],
+			[/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, "$1$2ves"],
+			[/([^aeiouy]|qu)y$/i, "$1ies"],
+			[/([^ch][ieo][ln])ey$/i, "$1ies"],
+			[/(x|ch|ss|sh|zz)$/i, "$1es"],
+			[/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, "$1ices"],
+			[/\b((?:tit)?m|l)(?:ice|ouse)$/i, "$1ice"],
+			[/(pe)(?:rson|ople)$/i, "$1ople"],
+			[/(child)(?:ren)?$/i, "$1ren"],
+			[/eaux$/i, "$0"],
+			[/m[ae]n$/i, "men"],
+			["thou", "you"]
+		].forEach(function(rule) {
+			return pluralize.addPluralRule(rule[0], rule[1]);
+		});
+		/**
+		* Singularization rules.
+		*/
+		[
+			[/s$/i, ""],
+			[/(ss)$/i, "$1"],
+			[/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, "$1fe"],
+			[/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, "$1f"],
+			[/ies$/i, "y"],
+			[/\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, "$1ie"],
+			[/\b(mon|smil)ies$/i, "$1ey"],
+			[/\b((?:tit)?m|l)ice$/i, "$1ouse"],
+			[/(seraph|cherub)im$/i, "$1"],
+			[/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, "$1"],
+			[/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, "$1sis"],
+			[/(movie|twelve|abuse|e[mn]u)s$/i, "$1"],
+			[/(test)(?:is|es)$/i, "$1is"],
+			[/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1us"],
+			[/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, "$1um"],
+			[/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, "$1on"],
+			[/(alumn|alg|vertebr)ae$/i, "$1a"],
+			[/(cod|mur|sil|vert|ind)ices$/i, "$1ex"],
+			[/(matr|append)ices$/i, "$1ix"],
+			[/(pe)(rson|ople)$/i, "$1rson"],
+			[/(child)ren$/i, "$1"],
+			[/(eau)x?$/i, "$1"],
+			[/men$/i, "man"]
+		].forEach(function(rule) {
+			return pluralize.addSingularRule(rule[0], rule[1]);
+		});
+		/**
+		* Uncountable rules.
+		*/
+		[
+			"adulthood",
+			"advice",
+			"agenda",
+			"aid",
+			"aircraft",
+			"alcohol",
+			"ammo",
+			"analytics",
+			"anime",
+			"athletics",
+			"audio",
+			"bison",
+			"blood",
+			"bream",
+			"buffalo",
+			"butter",
+			"carp",
+			"cash",
+			"chassis",
+			"chess",
+			"clothing",
+			"cod",
+			"commerce",
+			"cooperation",
+			"corps",
+			"debris",
+			"diabetes",
+			"digestion",
+			"elk",
+			"energy",
+			"equipment",
+			"excretion",
+			"expertise",
+			"firmware",
+			"flounder",
+			"fun",
+			"gallows",
+			"garbage",
+			"graffiti",
+			"hardware",
+			"headquarters",
+			"health",
+			"herpes",
+			"highjinks",
+			"homework",
+			"housework",
+			"information",
+			"jeans",
+			"justice",
+			"kudos",
+			"labour",
+			"literature",
+			"machinery",
+			"mackerel",
+			"mail",
+			"media",
+			"mews",
+			"moose",
+			"music",
+			"mud",
+			"manga",
+			"news",
+			"only",
+			"personnel",
+			"pike",
+			"plankton",
+			"pliers",
+			"police",
+			"pollution",
+			"premises",
+			"rain",
+			"research",
+			"rice",
+			"salmon",
+			"scissors",
+			"series",
+			"sewage",
+			"shambles",
+			"shrimp",
+			"software",
+			"species",
+			"staff",
+			"swine",
+			"tennis",
+			"traffic",
+			"transportation",
+			"trout",
+			"tuna",
+			"wealth",
+			"welfare",
+			"whiting",
+			"wildebeest",
+			"wildlife",
+			"you",
+			/pok[eé]mon$/i,
+			/[^aeiou]ese$/i,
+			/deer$/i,
+			/fish$/i,
+			/measles$/i,
+			/o[iu]s$/i,
+			/pox$/i,
+			/sheep$/i
+		].forEach(pluralize.addUncountableRule);
+		return pluralize;
+	});
+})))(), 1);
+/**
+* The name an entity's aggregate doctype is generated under: the entity's name, pluralised.
+*
+* One definition, because the CLI writes the file under `toSlug` of this and any later caller
+* (a scaffolder, a docs generator) must land on the same name or it silently addresses a
+* different file.
+*
+* `pluralize` rather than appending `s`, because the irregulars are not rare in practice —
+* measured against a consumer's 41 hand-authored aggregate doctypes, this rule reproduces every
+* one of their names, slugs and filenames exactly, while `+ 's'` gets five wrong
+* (`Currencys`, `JournalEntrys`, …).
+*
+* The rule is not total: an already-plural name pluralises to itself. Callers must handle that —
+* see {@link buildAggregateDoctype}.
+*
+* @param doctypeName - the entity doctype's `name`
+* @returns the aggregate doctype's `name`
+* @public
+*
+* @example
+* ```typescript
+* aggregateDoctypeName('SalesOrder') // 'SalesOrders' -> slug 'sales-orders'
+* ```
+*/
+function aggregateDoctypeName(doctypeName) {
+	return import_pluralize.default.plural(doctypeName);
+}
+/**
+* Derive the aggregate doctype for a converted entity.
+*
+* Returns `undefined` when no identity column can be found — a natural-key table whose key the
+* converter refuses to guess and whose author has not declared one, or a foreign PostGraphile
+* endpoint that has left the Relay identifier occupying `id` (Stonecrop's own preset moves it to
+* `nodeId`). That is deliberate: an aggregate with an empty `fields` array is a valid doctype that
+* renders a table with no columns, which looks like a data problem rather than a generation one.
+* Emitting nothing and saying so is the loud failure.
+*
+* Identity resolves the same way `getRecordIdField` resolves it — the declared `primaryKey`, then
+* the conventional `id` — so an aggregate is always keyed on the column the client will later ask
+* for. `declaredIdentity` overrides both: SDL cannot express which `UNIQUE` column is the key, so
+* for a natural-key table the answer only exists in the authored file, and the caller that read it
+* passes the fieldname back.
+*
+* @param doctype - a converted entity doctype, as returned by `convertGraphQLSchema`
+* @param declaredIdentity - fieldname the authored doctype declares as its `primaryKey`, when the
+*   caller has read one. Must name a field the converter emitted; the caller checks that, because
+*   only it can say whether a missing one is a dropped column or a typo.
+* @returns the aggregate doctype, or `undefined` when no identity column exists
+* @public
+*
+* @example
+* ```typescript
+* const [order] = convertGraphQLSchema(sdl, { include: ['Order'] })
+* const aggregate = buildAggregateDoctype(order)
+* // { name: 'Orders', slug: 'orders', fields: [ the id field ] }
+* ```
+*/
+function buildAggregateDoctype(doctype, declaredIdentity) {
+	const identity = findIdentityField(doctype.fields, declaredIdentity);
+	if (!identity) return void 0;
+	const name = aggregateDoctypeName(doctype.name);
+	if (name === doctype.name) return void 0;
+	const { source, ...rest } = identity;
+	return {
+		name,
+		slug: toSlug(name),
+		fields: [{
+			...rest,
+			primaryKey: true,
+			...source === void 0 ? {} : { source }
+		}]
+	};
+}
+/**
+* The field an aggregate is keyed on: an identity the author declared, else the primary key the
+* converter derived, else the conventional `id`.
+*
+* The author wins because the authored doctype is the source of truth — generation verifies it and
+* never overwrites it (see `mergeIntrospectedDoctype`), and the divergence is already reported as
+* identity drift.
+*
+* Calls `getPrimaryKeyField` for the derived half rather than restating it: a restatement drifted
+* exactly as one does, staying top-level while the helper learned to descend into fieldsets.
+*
+* @internal
+*/
+function findIdentityField(fields, declared) {
+	if (declared !== void 0) return fields.find((field) => field.fieldname === declared);
+	return getPrimaryKeyField(fields) ?? fields.find((field) => field.fieldname === "id");
+}
+/**
+* The doctypes in a run that get a URL of their own.
+*
+* A child table has no page: its rows exist inside a parent and are edited there, so a route for
+* it is an address nothing can link to. The declaration that says so is the parent's `links` entry
+* with a to-many cardinality — which the server derives from the foreign keys it treats as owning,
+* so this reads what the schema states rather than guessing from a name.
+*
+* The rule is *listed by something, referenced by nothing*. A single reference wins over any number
+* of listings, and the asymmetry is deliberate: a doctype that is both a parent's rows and another
+* doctype's link target — a recipe task, say, embedded in its recipe and pointed at by four other
+* records — needs somewhere for those links to navigate to. Denying it leaves the arrow on an
+* `AFormLink` dead, which fails silently; granting it leaves a URL nobody visits, which does not.
+*
+* Scoped to one run, so a partial generation sees a partial graph and grants more routes than a
+* whole one would. That is the safe direction, and the extra routes are deletable — an authored
+* file's keys survive regeneration untouched.
+*
+* @internal
+*/
+function routableDoctypes(entities) {
+	const listed = /* @__PURE__ */ new Set();
+	const referenced = /* @__PURE__ */ new Set();
+	for (const entity of entities) {
+		for (const link of Object.values(entity.links ?? {})) if (link.cardinality === "noneOrMany" || link.cardinality === "atLeastOne") listed.add(link.target);
+		else referenced.add(link.target);
+		for (const field of flattenFields(entity.fields)) if ("doctype" in field && typeof field.doctype === "string") referenced.add(field.doctype);
+	}
+	return new Set(entities.filter((entity) => {
+		const slug = getDoctypeSlug(entity);
+		return referenced.has(slug) || !listed.has(slug);
+	}).map((entity) => entity.name));
+}
+/**
+* Expand converted entities into the set of doctype files to write.
+*
+* Each table yields two: the entity, whose fields carry every column and which backs the record
+* form, and its aggregate — the collection view. They are written as peers, one file each, with
+* no key relating them.
+*
+* Separate from the CLI because the pairing of a file to its verification basis is the part that
+* is easy to get wrong and impossible to notice: getting it wrong does not throw, it just reports
+* drift that is not there, forever.
+*
+* @param entities - `convertGraphQLSchema` output
+* @param options - see {@link GenerationPlanOptions}
+* @returns one entry per file to write
+* @public
+*/
+function planGeneration(entities, options = {}) {
+	const entityNames = new Set(entities.map((entity) => entity.name));
+	const claimed = /* @__PURE__ */ new Set();
+	const routable = routableDoctypes(entities);
+	return entities.flatMap((entity) => {
+		const segment = `/${getDoctypeSlug(entity)}`;
+		const routed = routable.has(entity.name) ? {
+			...entity,
+			route: `${segment}/:id`
+		} : entity;
+		const self = {
+			generated: routed,
+			basis: routed,
+			subset: false
+		};
+		if (options.noAggregates) return [self];
+		const name = aggregateDoctypeName(entity.name);
+		if (name === entity.name) {
+			options.onWarning?.(`${entity.name} is already plural, so its aggregate would take the same name and the same file. No aggregate was generated. Rename the doctype to its singular form, or author ${entity.slug}.json's collection view by hand.`);
+			return [self];
+		}
+		if (entityNames.has(name) || claimed.has(name)) {
+			options.onWarning?.(`${entity.name}'s aggregate would be named ${name}, which is already taken by another doctype in this run. No aggregate was generated — one of the two needs an explicit name via the doctypeNames option.`);
+			return [self];
+		}
+		const declared = options.identity?.[entity.name];
+		if (declared !== void 0 && !entity.fields.some((field) => field.fieldname === declared)) {
+			options.onWarning?.(`${entity.name} declares its primaryKey on '${declared}', which the schema has no column for. No aggregate was generated — correct the declaration in ${entity.slug}.json, or restore the column to the table.`);
+			return [self];
+		}
+		const aggregate = buildAggregateDoctype(entity, declared);
+		if (!aggregate) {
+			options.onWarning?.(`${entity.name} has no derivable identity column, so no aggregate doctype was generated. Declare a primaryKey on ${entity.slug}.json and re-run.`);
+			return [self];
+		}
+		claimed.add(name);
+		return [self, {
+			generated: routable.has(entity.name) ? {
+				...aggregate,
+				route: segment
+			} : aggregate,
+			basis: entity,
+			subset: true
+		}];
+	});
+}
+//#endregion
+//#region src/converter/authored.ts
+/** @internal */
+function isAuthoredRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Flatten authored fields, descending into fieldsets.
+*
+* A fieldset is a layout grouping, not a scope: a field inside one is still a field of the doctype,
+* with a column of its own and a key it may declare.
+*
+* @internal
+*/
+function flattenAuthored(fields) {
+	const out = [];
+	for (const field of fields) if (Array.isArray(field.schema)) out.push(...flattenAuthored(field.schema.filter(isAuthoredRecord)));
+	else out.push(field);
+	return out;
+}
+/**
+* The fieldname an authored doctype declares as its identity, or `undefined` when it declares none.
+*
+* Descends into fieldsets, because a nested `primaryKey` is a real declaration — ignoring one is
+* what `getPrimaryKeyField` was fixed for.
+*
+* @internal
+*/
+function authoredPrimaryKey(doctype) {
+	if (!Array.isArray(doctype.fields)) return void 0;
+	const declared = flattenAuthored(doctype.fields.filter(isAuthoredRecord)).find((f) => f.primaryKey === true);
+	return typeof declared?.fieldname === "string" ? declared.fieldname : void 0;
+}
+//#endregion
+//#region src/converter/merge.ts
+/**
+* Merge introspected schema facts into an already-authored doctype.
+*
+* The authored doctype is the source of truth. Generation **verifies** it and stamps provenance;
+* it does not overwrite. That polarity is deliberate and load-bearing — a doctype legitimately
+* declares a `primaryKey` the schema cannot express. A natural business key is very often a
+* `UNIQUE` constraint rather than the table's `PRIMARY KEY`, and where a table carries several
+* uniques no rule can pick between them. Overwriting identity from the schema would silently
+* re-key such a doctype on every regeneration and break the handlers that key on the old value.
+*
+* So divergence is **reported, never applied** — a human decides. The only mutation this performs
+* is adding `source: 'introspected'` to fields confirmed to exist in the GraphQL schema.
+*
+* @packageDocumentation
+*/
+function describe(value) {
+	return value === void 0 ? "—" : JSON.stringify(value);
+}
+/**
+* Verify an authored doctype against freshly generated output and stamp provenance.
+*
+* @param authored - the doctype as it exists on disk; every key not named below is preserved verbatim
+* @param generated - `convertGraphQLSchema` output for the corresponding GraphQL type. For a
+*   `subset` merge this is the **entity**, whose fields are the set the subset is curated from
+* @param options - see {@link MergeOptions}
+* @returns the doctype to write, plus a drift report
+*
+* @example
+* ```ts
+* const [generated] = convertGraphQLSchema(introspection, { include: ['Uom'] })
+* const { doctype, drift } = mergeIntrospectedDoctype(JSON.parse(onDisk), generated)
+* if (drift.identityDrift.length) console.warn(drift.identityDrift.join('\n'))
+* ```
+*
+* @public
+*/
+function mergeIntrospectedDoctype(authored, generated, options = {}) {
+	const authoredFields = Array.isArray(authored.fields) ? authored.fields.filter(isAuthoredRecord) : [];
+	const generatedByName = new Map(generated.fields.map((f) => [f.fieldname, f]));
+	const generatedLinkNames = new Set(Object.keys(generated.links ?? {}));
+	const drift = {
+		doctype: typeof authored.name === "string" ? authored.name : "(unnamed)",
+		mode: "clean",
+		tagged: [],
+		orphan: [],
+		omitted: [],
+		componentDrift: [],
+		requiredDrift: [],
+		identityDrift: []
+	};
+	const tag = (field) => {
+		if (Array.isArray(field.schema)) return {
+			...field,
+			schema: field.schema.filter(isAuthoredRecord).map(tag)
+		};
+		const name = typeof field.fieldname === "string" ? field.fieldname : "";
+		const match = generatedByName.get(name);
+		if (!match) {
+			if (field.computed !== true && !generatedLinkNames.has(name)) drift.orphan.push(name);
+			return field;
+		}
+		drift.tagged.push(name);
+		if (match.component !== field.component) drift.componentDrift.push(`${name}: authored=${describe(field.component)} schema=${describe(match.component)}`);
+		if (Boolean(match.required) !== Boolean(field.required)) drift.requiredDrift.push(`${name}: authored=${Boolean(field.required)} schema=${Boolean(match.required)}`);
+		for (const prop of INTROSPECTED_IDENTITY_PROPS) {
+			if (prop === "fieldname" || prop === "required") continue;
+			const authoredValue = field[prop];
+			const schemaValue = match[prop];
+			if (authoredValue === void 0 && schemaValue === void 0) continue;
+			if (JSON.stringify(authoredValue) !== JSON.stringify(schemaValue)) drift.identityDrift.push(`${name}.${prop}: authored=${describe(authoredValue)} schema=${describe(schemaValue)}`);
+		}
+		return {
+			...field,
+			source: "introspected"
+		};
+	};
+	const merged = {
+		...authored,
+		fields: authoredFields.map(tag)
+	};
+	if (!options.subset) {
+		const authoredNames = new Set(flattenAuthored(authoredFields).map((f) => f.fieldname));
+		drift.omitted = generated.fields.map((f) => f.fieldname).filter((n) => !authoredNames.has(n));
+	}
+	const authoredPk = authoredPrimaryKey(authored);
+	const generatedPk = generated.fields.find((f) => f.primaryKey === true);
+	if (authoredPk && generatedPk && authoredPk !== generatedPk.fieldname) {
+		drift.mode = "partial";
+		drift.reason = `authored primary key '${authoredPk}' is not the derivable '${generatedPk.fieldname}' — left as authored`;
+	} else if (authoredPk && !generatedPk) {
+		drift.mode = "partial";
+		drift.reason = `authored primary key '${authoredPk}' is not derivable from the schema — left as authored`;
+	} else if (!authoredPk && generatedPk) {
+		drift.mode = "partial";
+		drift.reason = `schema suggests '${generatedPk.fieldname}' as primary key but the doctype declares none — not applied`;
+	}
+	return {
+		doctype: merged,
+		drift
+	};
+}
+/**
+* Render a drift report as human-readable lines. Empty when generation agrees with the doctype.
+*
+* @param drift - a report from {@link mergeIntrospectedDoctype}
+* @returns one line per finding, ready to print
+*
+* @public
+*/
+function formatDoctypeDrift(drift) {
+	const lines = [];
+	if (drift.reason) lines.push(`  ${drift.doctype}: ${drift.reason}`);
+	const bucket = (label, entries) => {
+		if (entries.length) lines.push(`  ${drift.doctype}: ${label} ${entries.join("; ")}`);
+	};
+	bucket("identity drift", drift.identityDrift);
+	bucket("component drift", drift.componentDrift);
+	bucket("required drift", drift.requiredDrift);
+	bucket("authored fields with no schema field:", drift.orphan);
+	bucket("schema fields not modelled:", drift.omitted);
+	return lines;
+}
+//#endregion
+//#region src/converter/index.ts
+/**
+* GraphQL Introspection to Stonecrop Schema Converter
+*
+* Converts a standard GraphQL introspection result (or SDL string) into
+* Stonecrop doctype schemas. Source-agnostic — works with any GraphQL server.
+*
+* @packageDocumentation
+*/
+/**
+* Convert a GraphQL schema to Stonecrop doctype schemas.
+*
+* Accepts either an `IntrospectionQuery` result object or an SDL string.
+* Entity types are identified using heuristics (or a custom `isEntityType` function)
+* and converted to `DoctypeMeta`-compatible JSON objects.
+*
+* @param source - GraphQL introspection result or SDL string
+* @param options - Conversion options for controlling output format and behavior
+* @returns Array of converted Stonecrop doctype definitions
+*
+* @example
+* ```typescript
+* // From introspection result (fetched from any GraphQL server)
+* const introspection = await fetchIntrospection('http://localhost:5000/graphql')
+* const doctypes = convertGraphQLSchema(introspection)
+*
+* // From SDL string
+* const sdl = fs.readFileSync('schema.graphql', 'utf-8')
+* const doctypes = convertGraphQLSchema(sdl)
+*
+* // With PostGraphile custom scalars
+* const doctypes = convertGraphQLSchema(introspection, {
+*   customScalars: {
+*     BigFloat: { component: 'ANumericInput' }
+*   }
+* })
+* ```
+*
+* @public
+*/
+function convertGraphQLSchema(source, options = {}) {
+	const schema = buildGraphQLSchema(source);
+	const typeMap = schema.getTypeMap();
+	const rootTypeNames = /* @__PURE__ */ new Set();
+	const queryType = schema.getQueryType();
+	const mutationType = schema.getMutationType();
+	const subscriptionType = schema.getSubscriptionType();
+	if (queryType) rootTypeNames.add(queryType.name);
+	if (mutationType) rootTypeNames.add(mutationType.name);
+	if (subscriptionType) rootTypeNames.add(subscriptionType.name);
+	const isEntityType = options.isEntityType ?? defaultIsEntityType;
+	const entityTypes = /* @__PURE__ */ new Set();
+	for (const [typeName, type] of Object.entries(typeMap)) {
+		if (!isObjectType(type)) continue;
+		if (rootTypeNames.has(typeName)) continue;
+		if (isEntityType(typeName, type)) entityTypes.add(typeName);
+	}
+	let filteredEntityTypes = entityTypes;
+	if (options.include) {
+		const includeSet = new Set(options.include);
+		filteredEntityTypes = new Set([...entityTypes].filter((t) => includeSet.has(t)));
+	}
+	if (options.exclude) {
+		const excludeSet = new Set(options.exclude);
+		filteredEntityTypes = new Set([...filteredEntityTypes].filter((t) => !excludeSet.has(t)));
+	}
+	const isEntityField = options.isEntityField ?? defaultIsEntityField;
+	const doctypes = [];
+	for (const typeName of filteredEntityTypes) {
+		const type = typeMap[typeName];
+		if (!isObjectType(type)) continue;
+		const fields = type.getFields();
+		const isUnnormalizedPostGraphile = "id" in fields && "rowId" in fields;
+		if (isUnnormalizedPostGraphile) options.onWarning?.(`${typeName}: schema exposes both 'id' (Relay identifier) and 'rowId' (the real column). Skipping 'id' and emitting 'rowId' verbatim — no primary key can be derived. Override the '_attributeName' and 'nodeIdFieldName' inflectors so the column keeps its own name.`);
+		const allClassifiedFields = Object.entries(fields).filter(([fieldName, field]) => isEntityField(fieldName, field, type) && !(isUnnormalizedPostGraphile && fieldName === "id")).map(([fieldName, field]) => {
+			if (options.classifyField) {
+				const custom = options.classifyField(fieldName, field, type);
+				if (custom !== null && custom !== void 0) return {
+					kind: "field",
+					fieldname: fieldName,
+					label: custom.label ?? fieldName,
+					component: custom.component ?? "ATextInput",
+					...custom
+				};
+			}
+			return classifyFieldType(fieldName, field, entityTypes, options);
+		});
+		const primaryKeyFieldname = allClassifiedFields.find((field) => field.fieldname === "id" && field.required && !field.doctype && !field._isLink)?.fieldname;
+		const links = {};
+		const convertedFields = allClassifiedFields.filter((field) => {
+			if (field._isLink && field.doctype && field.cardinality) {
+				links[field.fieldname] = {
+					target: field.doctype,
+					cardinality: field.cardinality
+				};
+				return false;
+			}
+			return true;
+		}).map((field) => {
+			const identity = field.fieldname === primaryKeyFieldname ? { primaryKey: true } : {};
+			if (!options.includeUnmappedMeta) {
+				const { _graphqlType, _unmapped, _isLink, ...clean } = field;
+				return Object.assign(clean, identity, { source: "introspected" });
+			}
+			const { _isLink, ...rest } = field;
+			return Object.assign(rest, identity, { source: "introspected" });
+		});
+		const doctypeName = options.doctypeNames?.[typeName] ?? typeName;
+		const doctype = {
+			name: doctypeName,
+			slug: toSlug(doctypeName),
+			fields: convertedFields
+		};
+		if (Object.keys(links).length > 0) doctype.links = links;
+		if (options.includeUnmappedMeta) doctype._graphqlTypeName = typeName;
+		doctypes.push(doctype);
+	}
+	return doctypes;
+}
+/**
+* Build a GraphQLSchema from either an introspection result or SDL string.
+*
+* @param source - IntrospectionQuery object or SDL string
+* @returns A complete GraphQLSchema
+* @internal
+*/
+function buildGraphQLSchema(source) {
+	if (typeof source === "string") return buildSchema(source);
+	return buildClientSchema(source);
+}
+//#endregion
+export { snakeToCamel as A, getPrimaryKeyField as B, WorkflowMeta as C, camelToLabel as D, linkDisplayFieldname as E, FieldsetFieldSchema as F, stripFieldKind as G, getRecordIdentity as H, INTROSPECTED_IDENTITY_PROPS as I, TableViewConfig as K, TableFieldSchema as L, toPascalCase as M, toSlug as N, camelToSnake as O, DoctypeFieldSchema as P, ValueFieldSchema as R, WorkflowLayout as S, isActionAllowedInState as T, inferFieldKind as U, getRecordIdField as V, normalizeFieldKind as W, validateDoctype as _, aggregateDoctypeName as a, LINK_DISPLAY_SUFFIX as b, classifyFieldType as c, GQL_SCALAR_MAP as d, INTERNAL_SCALARS as f, parseField as g, parseDoctype as h, authoredPrimaryKey as i, snakeToLabel as j, pascalToSnake as k, defaultIsEntityField as l, buildScalarMap as m, formatDoctypeDrift as n, buildAggregateDoctype as o, WELL_KNOWN_SCALARS as p, mergeIntrospectedDoctype as r, planGeneration as s, convertGraphQLSchema as t, defaultIsEntityType as u, validateField as v, getDoctypeSlug as w, TriggerDefinition as x, ActionDefinition as y, getDisplayField as z };
+
+//# sourceMappingURL=converter-CLwduvT_.js.map