@stonecrop/schema 0.16.4 → 0.16.5

package/dist/src/index.d.ts

@@ -2,11 +2,11 @@ export type { InteractionMode } from './mode';
 export { TableViewConfig } from './table';
 export { CANONICAL_COMPONENTS, COMPONENT_CATEGORY, COMPONENT_LINK_EXPANSION, componentCategory, componentLinkExpansion, resolveLinkRenderMode, type ComponentCategory, type LinkExpansion, type LinkRenderMode, } from './component-meta';
 export type { DoctypeField, FieldOptions, FieldValidation, FieldsetField, TableField, ValueField } from './field';
-export { DoctypeFieldSchema, FieldsetFieldSchema, normalizeFieldKind, TableFieldSchema, ValueFieldSchema, } from './field';
+export { DoctypeFieldSchema, FieldsetFieldSchema, getPrimaryKeyField, getRecordIdentity, INTROSPECTED_IDENTITY_PROPS, normalizeFieldKind, TableFieldSchema, ValueFieldSchema, } from './field';
 export { ActionDefinition, TriggerDefinition, WorkflowLayout, WorkflowMeta, isActionAllowedInState } from './doctype';
 export type { Cardinality, CustomFetch, DataClient, DoctypeContext, DoctypeMeta, DoctypeRef, FetchStrategy, GetRecordOptions, GetRecordResult, GetRecordsOptions, LazyFetch, LinkDeclaration, SerializedFunction, SyncFetch, } from './doctype';
 export { parseDoctype, parseField, validateDoctype, validateField, type ValidationError, type ValidationResult, } from './validation';
-export { buildScalarMap, classifyFieldType, convertGraphQLSchema, defaultIsEntityField, defaultIsEntityType, GQL_SCALAR_MAP, INTERNAL_SCALARS, WELL_KNOWN_SCALARS, type ConvertedGraphQLDoctype, type GraphQLConversionFieldMeta, type GraphQLConversionOptions, type IntrospectionSource, } from './converter';
+export { buildScalarMap, classifyFieldType, convertGraphQLSchema, defaultIsEntityField, defaultIsEntityType, formatDoctypeDrift, GQL_SCALAR_MAP, INTERNAL_SCALARS, mergeIntrospectedDoctype, WELL_KNOWN_SCALARS, type AuthoredDoctype, type ConvertedGraphQLDoctype, type DoctypeDrift, type GraphQLConversionFieldMeta, type GraphQLConversionOptions, type IntrospectionSource, type MergeResult, } from './converter';
 export { toSlug, toPascalCase, pascalToSnake, snakeToCamel, camelToSnake, snakeToLabel, camelToLabel } from './naming';
 export type { ColumnSchema } from './column-schema';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAA;AAG7C,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAGzC,OAAO,EACN,oBAAoB,EACpB,kBAAkB,EAClB,wBAAwB,EACxB,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EACrB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,cAAc,GACnB,MAAM,kBAAkB,CAAA;AAGzB,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AACjH,OAAO,EACN,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,GAChB,MAAM,SAAS,CAAA;AAKhB,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,cAAc,EAAE,YAAY,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAA;AACrH,YAAY,EACX,WAAW,EACX,WAAW,EACX,UAAU,EACV,cAAc,EACd,WAAW,EACX,UAAU,EACV,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,SAAS,EACT,eAAe,EACf,kBAAkB,EAClB,SAAS,GACT,MAAM,WAAW,CAAA;AAGlB,OAAO,EACN,YAAY,EACZ,UAAU,EACV,eAAe,EACf,aAAa,EACb,KAAK,eAAe,EACpB,KAAK,gBAAgB,GACrB,MAAM,cAAc,CAAA;AAGrB,OAAO,EACN,cAAc,EACd,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAClB,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,GACxB,MAAM,aAAa,CAAA;AAGpB,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAGtH,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAA;AAG7C,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAGzC,OAAO,EACN,oBAAoB,EACpB,kBAAkB,EAClB,wBAAwB,EACxB,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EACrB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,cAAc,GACnB,MAAM,kBAAkB,CAAA;AAGzB,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AACjH,OAAO,EACN,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,2BAA2B,EAC3B,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,GAChB,MAAM,SAAS,CAAA;AAKhB,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,cAAc,EAAE,YAAY,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAA;AACrH,YAAY,EACX,WAAW,EACX,WAAW,EACX,UAAU,EACV,cAAc,EACd,WAAW,EACX,UAAU,EACV,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,SAAS,EACT,eAAe,EACf,kBAAkB,EAClB,SAAS,GACT,MAAM,WAAW,CAAA;AAGlB,OAAO,EACN,YAAY,EACZ,UAAU,EACV,eAAe,EACf,aAAa,EACb,KAAK,eAAe,EACpB,KAAK,gBAAgB,GACrB,MAAM,cAAc,CAAA;AAGrB,OAAO,EACN,cAAc,EACd,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,kBAAkB,EAClB,cAAc,EACd,gBAAgB,EAChB,wBAAwB,EACxB,kBAAkB,EAClB,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,YAAY,EACjB,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACxB,KAAK,WAAW,GAChB,MAAM,aAAa,CAAA;AAGpB,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAGtH,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/src/index.js

@@ -2,7 +2,7 @@
 export { TableViewConfig } from './table';
 // Component → semantic category — the single source of "what kind of value does this component render"
 export { CANONICAL_COMPONENTS, COMPONENT_CATEGORY, COMPONENT_LINK_EXPANSION, componentCategory, componentLinkExpansion, resolveLinkRenderMode, } from './component-meta';
-export { DoctypeFieldSchema, FieldsetFieldSchema, normalizeFieldKind, TableFieldSchema, ValueFieldSchema, } from './field';
+export { DoctypeFieldSchema, FieldsetFieldSchema, getPrimaryKeyField, getRecordIdentity, INTROSPECTED_IDENTITY_PROPS, normalizeFieldKind, TableFieldSchema, ValueFieldSchema, } from './field';
 // Doctype schema
 // ActionDefinition and WorkflowMeta are exported as values (Zod schemas) so consumers can use
 // .safeParse(), .shape, etc. at runtime. TypeScript types are inferred from the same exports.
@@ -10,6 +10,6 @@ export { ActionDefinition, TriggerDefinition, WorkflowLayout, WorkflowMeta, isAc
 // Validation helpers
 export { parseDoctype, parseField, validateDoctype, validateField, } from './validation';
 // GraphQL to Doctype conversion
-export { buildScalarMap, classifyFieldType, convertGraphQLSchema, defaultIsEntityField, defaultIsEntityType, GQL_SCALAR_MAP, INTERNAL_SCALARS, WELL_KNOWN_SCALARS, } from './converter';
+export { buildScalarMap, classifyFieldType, convertGraphQLSchema, defaultIsEntityField, defaultIsEntityType, formatDoctypeDrift, GQL_SCALAR_MAP, INTERNAL_SCALARS, mergeIntrospectedDoctype, WELL_KNOWN_SCALARS, } from './converter';
 // Naming utilities
 export { toSlug, toPascalCase, pascalToSnake, snakeToCamel, camelToSnake, snakeToLabel, camelToLabel } from './naming';

package/dist/validation-CToUOy0a.js

@@ -0,0 +1,538 @@
+import { isScalarType as P, isEnumType as R, isObjectType as A, isNonNullType as v, isListType as V, isNamedType as z, buildSchema as B, buildClientSchema as K } from "graphql";
+import { z as e } from "zod";
+function je(t) {
+  return t.replace(/_([a-z])/g, (n, i) => i.toUpperCase());
+}
+function Oe(t) {
+  return t.replace(/[A-Z]/g, (n) => `_${n.toLowerCase()}`);
+}
+function Ce(t) {
+  return t.split("_").map((n) => n.charAt(0).toUpperCase() + n.slice(1).toLowerCase()).join(" ");
+}
+function W(t) {
+  const n = t.replace(/([A-Z])/g, " $1").trim();
+  return n.charAt(0).toUpperCase() + n.slice(1);
+}
+function G(t) {
+  return t.split(/[-_\s]+/).map((n) => n.charAt(0).toUpperCase() + n.slice(1).toLowerCase()).join("");
+}
+function T(t) {
+  return t.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function Ne(t) {
+  return t.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+}
+const J = {
+  String: { component: "ATextInput" },
+  Int: { component: "ANumericInput" },
+  Float: { component: "ANumericInput" },
+  Boolean: { component: "ACheckbox" },
+  ID: { component: "ATextInput" }
+}, Q = {
+  // Arbitrary precision / large numbers — all numeric variants render with ANumericInput.
+  BigFloat: { component: "ANumericInput" },
+  BigDecimal: { component: "ANumericInput" },
+  Decimal: { component: "ANumericInput" },
+  BigInt: { component: "ANumericInput" },
+  Long: { component: "ANumericInput" },
+  // Identifiers
+  UUID: { component: "ATextInput" },
+  // Date / Time — no dedicated Time SFC exists; Time falls back to a plain text input.
+  DateTime: { component: "ADateTime" },
+  Datetime: { component: "ADateTime" },
+  Date: { component: "ADate" },
+  Time: { component: "ATextInput" },
+  Interval: { component: "ADuration" },
+  Duration: { component: "ADuration" },
+  // Structured data
+  JSON: { component: "ACodeEditor" },
+  JSONObject: { component: "ACodeEditor" },
+  JsonNode: { component: "ACodeEditor" }
+}, Z = /* @__PURE__ */ new Set(["Cursor"]);
+function H(t) {
+  const n = { ...Q };
+  for (const [i, o] of Object.entries(J))
+    n[i] = o;
+  if (t)
+    for (const [i, o] of Object.entries(t))
+      n[i] = { component: o.component ?? "ATextInput" };
+  return n;
+}
+const Y = [
+  "Connection",
+  "Edge",
+  "Input",
+  "Patch",
+  "Payload",
+  "Condition",
+  "Filter",
+  "OrderBy",
+  "Aggregate",
+  "AggregateResult",
+  "AggregateFilter",
+  "DeleteResponse",
+  "InsertResponse",
+  "UpdateResponse",
+  "MutationResponse"
+], X = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]);
+function ee(t, n) {
+  if (t.startsWith("__") || X.has(t) || t === "Node")
+    return !1;
+  for (const o of Y)
+    if (t.endsWith(o))
+      return !1;
+  const i = n.getFields();
+  return Object.keys(i).length !== 0;
+}
+const te = /* @__PURE__ */ new Set(["nodeId", "__typename", "clientMutationId"]);
+function ne(t, n, i) {
+  return !te.has(t);
+}
+function I(t) {
+  let n = !1, i = !1, o = t;
+  if (v(o) && (n = !0, o = o.ofType), V(o) && (i = !0, o = o.ofType, v(o) && (o = o.ofType)), !z(o))
+    throw new Error(`Expected a named GraphQL type, got: ${String(o)}`);
+  return { namedType: o, required: n, isList: i };
+}
+function ie(t) {
+  const i = t.getFields().edges;
+  if (!i) return;
+  const { namedType: o, isList: r } = I(i.type);
+  if (!r || !A(o)) return;
+  const f = o.getFields().node;
+  if (!f) return;
+  const { namedType: g } = I(f.type);
+  if (A(g))
+    return g.name;
+}
+function oe(t, n, i, o = {}) {
+  const { namedType: r, required: p, isList: f } = I(n.type), g = H(o.customScalars), a = {
+    kind: "field",
+    fieldname: t,
+    label: W(t),
+    component: "ATextInput"
+  };
+  if (p && (a.required = !0), P(r)) {
+    if (Z.has(r.name))
+      return a._unmapped = !0, o.includeUnmappedMeta && (a._graphqlType = r.name), a;
+    if (r.name === "ID") {
+      const u = G(t);
+      if (i.has(u))
+        return a.component = "AFormLink", a.doctype = T(u), a;
+    }
+    const l = g[r.name];
+    return l ? a.component = l.component : (a._unmapped = !0, o.includeUnmappedMeta && (a._graphqlType = r.name)), a;
+  }
+  if (R(r))
+    return a.component = "ADropdown", a.options = r.getValues().map((l) => l.name), a;
+  if (A(r)) {
+    if (!f && i.has(r.name))
+      return a.component = "AFormLink", a.doctype = T(r.name), a;
+    const l = ie(r);
+    return l && i.has(l) ? (a.component = "ATable", a._isLink = !0, a.doctype = T(l), a.cardinality = "noneOrMany", a) : f && i.has(r.name) ? (a.component = "ATable", a._isLink = !0, a.doctype = T(r.name), a.cardinality = "noneOrMany", a) : (a._unmapped = !0, o.includeUnmappedMeta && (a._graphqlType = r.name), a);
+  }
+  return a._unmapped = !0, o.includeUnmappedMeta && (a._graphqlType = r.name), a;
+}
+const ae = e.object({
+  /** The table view type */
+  view: e.enum(["list", "uncounted", "list-expansion", "tree", "gantt", "tree-gantt"]).optional(),
+  /** Allow the table to use the full width of its container */
+  fullWidth: e.boolean().optional(),
+  /** Default expansion state for tree views */
+  defaultTreeExpansion: e.enum(["root", "branch", "leaf"]).optional(),
+  /** Enable dependency graph connections for Gantt views */
+  dependencyGraph: e.boolean().optional()
+}).meta({
+  title: "TableViewConfig",
+  description: "JSON-safe view configuration for table fields in doctype authoring"
+}), re = e.union([
+  e.array(e.string()),
+  // Select choices: ["A", "B", "C"]
+  e.record(e.string(), e.unknown())
+  // Config: \{ precision: 10, scale: 2 \}
+]).meta({
+  title: "FieldOptions",
+  description: "Field options - flexible bag for type-specific configuration"
+}), se = e.looseObject({
+  /** Error message to display when validation fails */
+  errorMessage: e.string()
+}).meta({
+  title: "FieldValidation",
+  description: "Validation configuration for form fields"
+});
+function M(t) {
+  if (typeof t != "object" || t === null || Array.isArray(t)) return t;
+  const n = t;
+  return "kind" in n ? t : "schema" in n ? { kind: "fieldset", ...n } : "columns" in n ? { kind: "table", ...n } : { kind: "field", ...n };
+}
+function ce(t) {
+  const n = M(t);
+  if (typeof n != "object" || n === null) return n;
+  const i = n;
+  return i.kind === "fieldset" && Array.isArray(i.schema) ? { ...i, schema: i.schema.map(ce) } : n;
+}
+const le = [
+  "fieldname",
+  "primaryKey",
+  "required",
+  "options",
+  "cardinality",
+  "doctype"
+];
+function de(t) {
+  return t.find((n) => n.kind === "field" && !!n.primaryKey);
+}
+function ve(t, n) {
+  const i = de(t), o = i ? [n[i.fieldname], n.id] : [n.id];
+  for (const r of o) {
+    if (typeof r == "number") return String(r);
+    if (typeof r == "string" && r !== "") return r;
+  }
+}
+function pe() {
+  const t = e.object({
+    kind: e.literal("field"),
+    fieldname: e.string().min(1),
+    component: e.string().min(1),
+    primaryKey: e.boolean().optional(),
+    computed: e.boolean().optional(),
+    language: e.string().optional(),
+    doctype: e.string().min(1).optional(),
+    label: e.string().optional(),
+    width: e.string().optional(),
+    align: e.enum(["left", "center", "right", "start", "end"]).optional(),
+    edit: e.boolean().optional(),
+    mask: e.string().optional(),
+    format: e.string().optional(),
+    mode: e.enum(["edit", "read", "display"]).optional(),
+    options: re.optional(),
+    required: e.boolean().optional(),
+    readOnly: e.boolean().optional(),
+    hidden: e.boolean().optional(),
+    default: e.unknown().optional(),
+    validation: se.optional(),
+    cardinality: e.enum(["atMostOne", "one", "noneOrMany", "atLeastOne"]).optional(),
+    source: e.literal("introspected").optional()
+  }).meta({ title: "ValueField" }), n = e.object({
+    kind: e.literal("table"),
+    fieldname: e.string().min(1),
+    component: e.string().optional(),
+    label: e.string().optional(),
+    // Validates that each column has fieldname; allows all other ColumnSchema properties
+    columns: e.array(e.object({ fieldname: e.string().min(1) }).passthrough()),
+    config: ae.optional(),
+    mode: e.enum(["edit", "read", "display"]).optional()
+  }).meta({ title: "TableField" });
+  let i = e.never();
+  const o = e.object({
+    kind: e.literal("fieldset"),
+    fieldname: e.string().min(1),
+    component: e.string().optional(),
+    label: e.string().optional(),
+    collapsible: e.boolean().optional(),
+    mode: e.enum(["edit", "read", "display"]).optional(),
+    schema: e.lazy(() => i.array())
+  }).meta({ title: "FieldsetField" }), r = e.discriminatedUnion("kind", [t, o, n]);
+  return i = e.preprocess(M, r), { ValueFieldSchema: t, TableFieldSchema: n, FieldsetFieldSchema: o, DoctypeFieldSchema: i };
+}
+const w = pe(), Me = w.ValueFieldSchema, $e = w.FieldsetFieldSchema, qe = w.TableFieldSchema, O = w.DoctypeFieldSchema;
+function L(t) {
+  const n = [];
+  for (const i of t)
+    Array.isArray(i.schema) ? n.push(...L(i.schema.filter(j))) : n.push(i);
+  return n;
+}
+function j(t) {
+  return typeof t == "object" && t !== null && !Array.isArray(t);
+}
+function k(t) {
+  return t === void 0 ? "—" : JSON.stringify(t);
+}
+function Ee(t, n) {
+  const i = Array.isArray(t.fields) ? t.fields.filter(j) : [], o = new Map(n.fields.map((s) => [s.fieldname, s])), r = new Set(Object.keys(n.links ?? {})), p = {
+    doctype: typeof t.name == "string" ? t.name : "(unnamed)",
+    mode: "clean",
+    tagged: [],
+    orphan: [],
+    omitted: [],
+    componentDrift: [],
+    requiredDrift: [],
+    identityDrift: []
+  }, f = (s) => {
+    if (Array.isArray(s.schema))
+      return { ...s, schema: s.schema.filter(j).map(f) };
+    const y = typeof s.fieldname == "string" ? s.fieldname : "", d = o.get(y);
+    if (!d)
+      return s.computed !== !0 && !r.has(y) && p.orphan.push(y), s;
+    p.tagged.push(y), d.component !== s.component && p.componentDrift.push(`${y}: authored=${k(s.component)} schema=${k(d.component)}`), !!d.required != !!s.required && p.requiredDrift.push(`${y}: authored=${!!s.required} schema=${!!d.required}`);
+    for (const m of le) {
+      if (m === "fieldname" || m === "required") continue;
+      const h = s[m], S = d[m];
+      h === void 0 && S === void 0 || JSON.stringify(h) !== JSON.stringify(S) && p.identityDrift.push(`${y}.${m}: authored=${k(h)} schema=${k(S)}`);
+    }
+    return { ...s, source: "introspected" };
+  }, g = { ...t, fields: i.map(f) }, a = new Set(L(i).map((s) => s.fieldname));
+  p.omitted = n.fields.map((s) => s.fieldname).filter((s) => !a.has(s));
+  const l = L(i).find((s) => s.primaryKey === !0), u = n.fields.find((s) => s.primaryKey === !0);
+  return l && u && l.fieldname !== u.fieldname ? (p.mode = "partial", p.reason = `authored primary key '${String(l.fieldname)}' is not the derivable '${u.fieldname}' — left as authored`) : l && !u ? (p.mode = "partial", p.reason = `authored primary key '${String(l.fieldname)}' is not derivable from the schema — left as authored`) : !l && u && (p.mode = "partial", p.reason = `schema suggests '${u.fieldname}' as primary key but the doctype declares none — not applied`), { doctype: g, drift: p };
+}
+function xe(t) {
+  const n = [];
+  t.reason && n.push(`  ${t.doctype}: ${t.reason}`);
+  const i = (o, r) => {
+    r.length && n.push(`  ${t.doctype}: ${o} ${r.join("; ")}`);
+  };
+  return i("identity drift", t.identityDrift), i("component drift", t.componentDrift), i("required drift", t.requiredDrift), i("authored fields with no schema field:", t.orphan), i("schema fields not modelled:", t.omitted), n;
+}
+function Ue(t, n = {}) {
+  const i = me(t), o = i.getTypeMap(), r = /* @__PURE__ */ new Set(), p = i.getQueryType(), f = i.getMutationType(), g = i.getSubscriptionType();
+  p && r.add(p.name), f && r.add(f.name), g && r.add(g.name);
+  const a = n.isEntityType ?? ee, l = /* @__PURE__ */ new Set();
+  for (const [d, m] of Object.entries(o))
+    A(m) && (r.has(d) || a(d, m) && l.add(d));
+  let u = l;
+  if (n.include) {
+    const d = new Set(n.include);
+    u = new Set([...l].filter((m) => d.has(m)));
+  }
+  if (n.exclude) {
+    const d = new Set(n.exclude);
+    u = new Set([...u].filter((m) => !d.has(m)));
+  }
+  const s = n.isEntityField ?? ne, y = [];
+  for (const d of u) {
+    const m = o[d];
+    if (!A(m)) continue;
+    const h = m.getFields(), S = "id" in h && "rowId" in h;
+    S && n.onWarning?.(
+      `${d}: 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 C = Object.entries(h).filter(
+      ([c, b]) => s(c, b, m) && !(S && c === "id")
+    ).map(([c, b]) => {
+      if (n.classifyField) {
+        const F = n.classifyField(c, b, m);
+        if (F != null)
+          return {
+            kind: "field",
+            fieldname: c,
+            label: F.label ?? c,
+            component: F.component ?? "ATextInput",
+            ...F
+          };
+      }
+      return oe(c, b, l, n);
+    }), q = C.find(
+      (c) => c.fieldname === "id" && c.required && !c.doctype && !c._isLink
+    )?.fieldname, D = {}, E = C.filter((c) => c._isLink && c.doctype && c.cardinality ? (D[c.fieldname] = {
+      target: c.doctype,
+      cardinality: c.cardinality
+    }, !1) : !0).map((c) => {
+      const b = c.fieldname === q ? { primaryKey: !0 } : {};
+      if (!n.includeUnmappedMeta) {
+        const { _graphqlType: we, _unmapped: De, _isLink: _e, ...U } = c;
+        return Object.assign(U, b, { source: "introspected" });
+      }
+      const { _isLink: F, ...x } = c;
+      return Object.assign(x, b, { source: "introspected" });
+    }), N = n.doctypeNames?.[d] ?? d, _ = {
+      name: N,
+      slug: T(N),
+      fields: E
+    };
+    Object.keys(D).length > 0 && (_.links = D), n.includeUnmappedMeta && (_._graphqlTypeName = d), y.push(_);
+  }
+  return y;
+}
+function me(t) {
+  return typeof t == "string" ? B(t) : K(t);
+}
+const ue = e.enum(["atMostOne", "one", "noneOrMany", "atLeastOne"]).meta({
+  title: "Cardinality",
+  description: "Cardinality for relationship links between doctypes"
+}), fe = e.object({
+  /** Fetch method type */
+  method: e.literal("sync"),
+  /** Optional limit on number of records to fetch */
+  limit: e.number().int().positive().optional()
+}).meta({
+  title: "SyncFetch",
+  description: "Sync fetch strategy - data is fetched in the initial query"
+}), ye = e.object({
+  /** Fetch method type */
+  method: e.literal("lazy")
+}).meta({
+  title: "LazyFetch",
+  description: "Lazy fetch strategy - data is fetched on demand in a separate query"
+}), ge = e.object({
+  /** Fetch method type */
+  method: e.literal("custom"),
+  /** Serialized handler function to invoke */
+  handler: e.string()
+}).meta({
+  title: "CustomFetch",
+  description: "Custom fetch strategy - uses a custom handler function"
+}), he = e.discriminatedUnion("method", [fe, ye, ge]).meta({
+  title: "FetchStrategy",
+  description: "Fetch strategy for link data loading"
+}), be = e.object({
+  /** Target doctype slug */
+  target: e.string().min(1),
+  /** Cardinality of the relationship */
+  cardinality: ue,
+  /** Backlink fieldname on the target doctype that points back to this link */
+  backlink: e.string().optional(),
+  /** Override default rendering component (AForm for 1:1, ATable for 1:many) */
+  component: e.string().optional(),
+  /** Fieldname of the corresponding Link field in the fields array */
+  fieldname: e.string().min(1).optional(),
+  /** Fetch strategy for loading nested data */
+  fetch: he.optional(),
+  /** Whether to block workflow actions until nested data is loaded (default: true) */
+  blockWorkflows: e.boolean().optional()
+}).meta({
+  title: "LinkDeclaration",
+  description: "Declares a relationship from one doctype to another"
+}), Se = e.object({
+  /** Display label for the action */
+  label: e.string().min(1),
+  /** Fields that must have values before action can execute */
+  requiredFields: e.array(e.string()).optional(),
+  /** Workflow states where this action is available */
+  allowedStates: e.array(e.string()).optional(),
+  /** The state the record transitions to after this action executes */
+  nextState: e.string().optional(),
+  /** True for stateless command actions with no workflow effect at all (print, email, etc.) */
+  stateless: e.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: e.boolean().optional(),
+  /** JS function body stored as a string; executed client-side via AsyncFunction with injected API surface */
+  clientHandler: e.string().optional()
+}).meta({
+  title: "ActionDefinition",
+  description: "Action definition within a workflow"
+}), Fe = e.object({
+  /** Optional display label; the map key is the trigger's identity */
+  label: e.string().optional(),
+  /** Fieldnames whose edits fire this trigger (fires when any listed field changes) */
+  on: e.array(e.string()),
+  /** JS function body stored as a string; run client-side with `{ record, value, setError }`. Advisory. */
+  clientHandler: e.string()
+}).meta({
+  title: "TriggerDefinition",
+  description: "Reactive field-validation trigger — advisory client-side"
+});
+function Pe(t, n) {
+  const i = t.allowedStates;
+  return !i || i.length === 0 ? !0 : i.includes(n);
+}
+const Te = e.record(
+  e.string(),
+  e.object({
+    position: e.object({ x: e.number(), y: e.number() }).optional(),
+    targetPosition: e.enum(["left", "top", "right", "bottom"]).optional(),
+    sourcePosition: e.enum(["left", "top", "right", "bottom"]).optional()
+  })
+), Ae = e.object({
+  /** List of workflow states */
+  states: e.array(e.string()).optional(),
+  /** Actions available in this workflow */
+  actions: e.record(e.string(), Se).optional(),
+  /** Reactive field-validation triggers (advisory, client-side), keyed by trigger name */
+  triggers: e.record(e.string(), Fe).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: Te.optional()
+}).meta({
+  title: "WorkflowMeta",
+  description: "Workflow metadata - states and actions for a doctype"
+}), $ = e.object({
+  /** Display name of the doctype */
+  name: e.string().min(1),
+  /** URL-friendly slug (kebab-case) */
+  slug: e.string().min(1).optional(),
+  /** Field definitions (a link field is one carrying `doctype`) */
+  fields: e.array(O),
+  /** Relationship links to other doctypes */
+  links: e.record(e.string(), be).optional(),
+  /** Workflow configuration */
+  workflow: Ae.optional(),
+  /** Parent doctype for inheritance */
+  inherits: e.string().optional()
+}).meta({
+  title: "DoctypeMeta",
+  description: "Doctype metadata - complete definition of a doctype"
+});
+function Re(t) {
+  const n = O.safeParse(t);
+  return n.success ? { success: !0, errors: [] } : {
+    success: !1,
+    errors: n.error.issues.map((i) => ({
+      path: i.path,
+      message: i.message
+    }))
+  };
+}
+function Ve(t) {
+  const n = $.safeParse(t);
+  return n.success ? { success: !0, errors: [] } : {
+    success: !1,
+    errors: n.error.issues.map((i) => ({
+      path: i.path,
+      message: i.message
+    }))
+  };
+}
+function ze(t) {
+  return O.parse(t);
+}
+function Be(t) {
+  return $.parse(t);
+}
+export {
+  Se as A,
+  Re as B,
+  O as D,
+  $e as F,
+  J as G,
+  Z as I,
+  qe as T,
+  Me as V,
+  Q as W,
+  le as a,
+  ae as b,
+  Ue as c,
+  Fe as d,
+  Te as e,
+  xe as f,
+  Ae as g,
+  H as h,
+  W as i,
+  Oe as j,
+  oe as k,
+  ne as l,
+  Ee as m,
+  ee as n,
+  de as o,
+  ve as p,
+  Pe as q,
+  ce as r,
+  Be as s,
+  ze as t,
+  Ne as u,
+  Ve as v,
+  je as w,
+  Ce as x,
+  G as y,
+  T as z
+};
+//# sourceMappingURL=validation-CToUOy0a.js.map