@contractspec/lib.contracts 0.0.0-canary-20260113162409

package/dist/registry.d.ts

@@ -0,0 +1,32 @@
+import { OwnerShipMeta } from "./ownership.js";
+import { GroupKeyFn, RegistryFilter } from "./registry-utils.js";
+import { ContractSpecType } from "./types.js";
+
+//#region src/registry.d.ts
+interface AnySpecContract {
+  meta: OwnerShipMeta;
+}
+declare const keyOfSpecContract: (spec: AnySpecContract) => string;
+/** In-memory registry for PresentationSpec. */
+declare abstract class SpecContractRegistry<ContractType extends ContractSpecType, SpecContract extends AnySpecContract> {
+  protected readonly contractType: ContractType;
+  protected items: Map<string, SpecContract>;
+  protected constructor(contractType: ContractType, items?: SpecContract[]);
+  register(p: SpecContract): this;
+  count(): number;
+  list(): SpecContract[];
+  get(key: string, version?: string): SpecContract | undefined;
+  has(key: string, version?: string): boolean;
+  /** Filter presentations by criteria. */
+  filter(criteria: RegistryFilter): SpecContract[];
+  /** List presentations with specific tag. */
+  listByTag(tag: string): SpecContract[];
+  /** List presentations by owner. */
+  listByOwner(owner: string): SpecContract[];
+  /** Group presentations by key function. */
+  groupBy(keyFn: GroupKeyFn<SpecContract>): Map<string, SpecContract[]>;
+  /** Get unique tags from all presentations. */
+  getUniqueTags(): string[];
+}
+//#endregion
+export { AnySpecContract, SpecContractRegistry, keyOfSpecContract };

package/dist/registry.js

@@ -0,0 +1,61 @@
+import { filterBy, getUniqueTags, groupBy, init_registry_utils } from "./registry-utils.js";
+import { compareVersions } from "compare-versions";
+
+//#region src/registry.ts
+init_registry_utils();
+const keyOfSpecContract = (spec) => `${spec.meta.key}.v${spec.meta.version}`;
+/** In-memory registry for PresentationSpec. */
+var SpecContractRegistry = class {
+	items = /* @__PURE__ */ new Map();
+	constructor(contractType, items) {
+		this.contractType = contractType;
+		if (items) items.forEach((p) => this.register(p));
+	}
+	register(p) {
+		const key = keyOfSpecContract(p);
+		if (this.items.has(key)) throw new Error(`Duplicate contract \`${this.contractType}\` ${key}`);
+		this.items.set(key, p);
+		return this;
+	}
+	count() {
+		return this.items.size;
+	}
+	list() {
+		return [...this.items.values()];
+	}
+	get(key, version) {
+		if (version != null) return this.items.get(`${key}.v${version}`);
+		let candidate;
+		for (const [k, p] of this.items.entries()) {
+			if (!k.startsWith(`${key}.v`)) continue;
+			if (!candidate || compareVersions(p.meta.version, candidate.meta.version) > 0) candidate = p;
+		}
+		return candidate;
+	}
+	has(key, version) {
+		return !!this.get(key, version);
+	}
+	/** Filter presentations by criteria. */
+	filter(criteria) {
+		return filterBy(this.list(), criteria);
+	}
+	/** List presentations with specific tag. */
+	listByTag(tag) {
+		return this.list().filter((p) => p.meta.tags?.includes(tag));
+	}
+	/** List presentations by owner. */
+	listByOwner(owner) {
+		return this.list().filter((p) => p.meta.owners?.includes(owner));
+	}
+	/** Group presentations by key function. */
+	groupBy(keyFn) {
+		return groupBy(this.list(), keyFn);
+	}
+	/** Get unique tags from all presentations. */
+	getUniqueTags() {
+		return getUniqueTags(this.list());
+	}
+};
+
+//#endregion
+export { SpecContractRegistry, keyOfSpecContract };

package/dist/resources.d.ts

@@ -0,0 +1,64 @@
+import { Tag } from "./ownership.js";
+import * as z$2 from "zod";
+
+//#region src/resources.d.ts
+interface ResourceMeta {
+  /** URI scheme, e.g. "content://doc/{id}" or "marketplace://offers/{city}/{tag}" */
+  uriTemplate: string;
+  /** Human title for discovery */
+  title: string;
+  /** Short description */
+  description?: string;
+  /** MIME type for resource body */
+  mimeType: string;
+  /** Tags for filtering/grouping */
+  tags?: Tag[];
+}
+interface ResourceTemplateSpec<I extends z$2.ZodType> {
+  meta: ResourceMeta;
+  /** Arguments to materialize the URI (zod validates input) */
+  input: I;
+  /**
+   * Resolve returns the resource body and a resolved URI.
+   * It MUST be read-only (no side effects).
+   */
+  resolve: (args: z$2.infer<I>, ctx: {
+    userId?: string | null;
+    orgId?: string | null;
+    locale?: string;
+  }) => Promise<{
+    uri: string;
+    mimeType?: string;
+    data: Uint8Array | string;
+  }>;
+}
+declare function defineResourceTemplate<I extends z$2.ZodType>(spec: ResourceTemplateSpec<I>): ResourceTemplateSpec<I>;
+declare class ResourceRegistry {
+  private templates;
+  register<I extends z$2.ZodType>(tmpl: ResourceTemplateSpec<I>): this;
+  listTemplates(): ResourceTemplateSpec<any>[];
+  /** Try to match a concrete URI to a template by naive pattern substitution */
+  match(uri: string): {
+    tmpl: ResourceTemplateSpec<any>;
+    params: Record<string, string>;
+  } | undefined;
+}
+interface ResourceRefDescriptor<Many extends boolean> {
+  kind: 'resource_ref';
+  /** URI template, e.g. 'strit://spot/{id}' */
+  uriTemplate: string;
+  /** Variable name inside result payload to substitute into template; defaults to 'id' */
+  varName?: string;
+  /** Optional GraphQL type name to use when exposing over GraphQL (e.g., 'Spot') */
+  graphQLType: string;
+  /** Cardinality: when present and true, the handler returns an array of resources */
+  many: Many;
+}
+declare function resourceRef<Many extends boolean>(uriTemplate: string, opts: {
+  varName?: string;
+  graphQLType: string;
+  many: Many;
+}): ResourceRefDescriptor<Many>;
+declare function isResourceRef(x: unknown): x is ResourceRefDescriptor<boolean>;
+//#endregion
+export { ResourceMeta, ResourceRefDescriptor, ResourceRegistry, ResourceTemplateSpec, defineResourceTemplate, isResourceRef, resourceRef };

package/dist/resources.js

@@ -0,0 +1,50 @@
+import "zod";
+
+//#region src/resources.ts
+function defineResourceTemplate(spec) {
+	return spec;
+}
+var ResourceRegistry = class {
+	templates = [];
+	register(tmpl) {
+		this.templates.push(tmpl);
+		return this;
+	}
+	listTemplates() {
+		return [...this.templates];
+	}
+	/** Try to match a concrete URI to a template by naive pattern substitution */
+	match(uri) {
+		for (const tmpl of this.templates) {
+			const re = /* @__PURE__ */ new RegExp("^" + tmpl.meta.uriTemplate.replace(/\{[^}]+\}/g, "([^/]+)") + "$");
+			const m = uri.match(re);
+			if (!m) continue;
+			const names = [...tmpl.meta.uriTemplate.matchAll(/\{([^}]+)\}/g)].map((x) => x[1]);
+			const params = {};
+			names.forEach((n, i) => {
+				const val = m[i + 1];
+				if (n && val) params[n] = decodeURIComponent(val);
+			});
+			return {
+				tmpl,
+				params
+			};
+		}
+	}
+};
+function resourceRef(uriTemplate, opts) {
+	return {
+		kind: "resource_ref",
+		uriTemplate,
+		varName: opts.varName ?? "id",
+		graphQLType: opts.graphQLType,
+		many: opts.many
+	};
+}
+function isResourceRef(x) {
+	const o = x;
+	return !!o && o.kind === "resource_ref" && typeof o.uriTemplate === "string";
+}
+
+//#endregion
+export { ResourceRegistry, defineResourceTemplate, isResourceRef, resourceRef };

package/dist/schema-to-markdown.d.ts

@@ -0,0 +1,54 @@
+import { AnySchemaModel } from "@contractspec/lib.schema";
+
+//#region src/schema-to-markdown.d.ts
+
+/**
+ * Options for schema-to-markdown generation
+ */
+interface SchemaMarkdownOptions {
+  /** Title for the markdown section */
+  title?: string;
+  /** Description to include below the title */
+  description?: string;
+  /** Output format: table for lists, list for simple items, detail for single objects */
+  format?: 'table' | 'list' | 'detail' | 'auto';
+  /** Maximum number of items to render (for arrays) */
+  maxItems?: number;
+  /** Only include these fields (if not specified, all fields are included) */
+  includeFields?: string[];
+  /** Exclude these fields from output */
+  excludeFields?: string[];
+  /** Custom field labels (field name -> display label) */
+  fieldLabels?: Record<string, string>;
+  /** Fields to use for summary in list format */
+  summaryFields?: string[];
+  /** Nesting depth for nested schemas (default: 2) */
+  maxDepth?: number;
+}
+/**
+ * Generate markdown from a SchemaModel and data.
+ * Automatically detects array vs object data and formats accordingly.
+ */
+declare function schemaToMarkdown(schema: AnySchemaModel, data: unknown, options?: SchemaMarkdownOptions): string;
+/**
+ * Generate a markdown table from array data using schema fields as columns.
+ */
+declare function schemaToMarkdownTable(schema: AnySchemaModel, items: unknown[], options?: SchemaMarkdownOptions): string;
+/**
+ * Generate a markdown list from array data.
+ * Uses summaryFields to create concise list items.
+ */
+declare function schemaToMarkdownList(schema: AnySchemaModel, items: unknown[], options?: SchemaMarkdownOptions): string;
+/**
+ * Generate a markdown detail view (key-value pairs) from object data.
+ */
+declare function schemaToMarkdownDetail(schema: AnySchemaModel, item: unknown, options?: SchemaMarkdownOptions): string;
+/**
+ * Generate markdown summary statistics for numeric fields in array data.
+ */
+declare function schemaToMarkdownSummary(items: unknown[], options?: {
+  numericFields?: string[];
+  countByField?: string;
+}): string;
+//#endregion
+export { SchemaMarkdownOptions, schemaToMarkdown, schemaToMarkdownDetail, schemaToMarkdownList, schemaToMarkdownSummary, schemaToMarkdownTable };

package/dist/schema-to-markdown.js

@@ -0,0 +1,217 @@
+import { isSchemaModel } from "@contractspec/lib.schema";
+
+//#region src/schema-to-markdown.ts
+/**
+* Generate markdown from a SchemaModel and data.
+* Automatically detects array vs object data and formats accordingly.
+*/
+function schemaToMarkdown(schema, data, options = {}) {
+	const { format = "auto", title, description, maxDepth = 2 } = options;
+	const lines = [];
+	if (title) lines.push(`# ${title}`, "");
+	if (description) lines.push(`> ${description}`, "");
+	const effectiveFormat = format === "auto" ? Array.isArray(data) ? "table" : "detail" : format;
+	if (effectiveFormat === "table" && Array.isArray(data)) lines.push(schemaToMarkdownTable(schema, data, options));
+	else if (effectiveFormat === "list" && Array.isArray(data)) lines.push(schemaToMarkdownList(schema, data, options));
+	else if (!Array.isArray(data) && data !== null && typeof data === "object") lines.push(schemaToMarkdownDetail(schema, data, {
+		...options,
+		maxDepth
+	}));
+	else lines.push(`**Data:** ${String(data)}`, "");
+	return lines.join("\n");
+}
+/**
+* Generate a markdown table from array data using schema fields as columns.
+*/
+function schemaToMarkdownTable(schema, items, options = {}) {
+	const { maxItems = 100, includeFields, excludeFields = [] } = options;
+	const fields = getFieldMeta(schema, includeFields, excludeFields);
+	if (fields.length === 0 || items.length === 0) return "_No data available_\n";
+	const limitedItems = items.slice(0, maxItems);
+	const lines = [];
+	const headers = fields.map((f) => f.label);
+	lines.push(`| ${headers.join(" | ")} |`);
+	lines.push(`| ${headers.map(() => "---").join(" | ")} |`);
+	for (const item of limitedItems) {
+		const row = fields.map((f) => formatCellValue(getFieldValue(item, f.name)));
+		lines.push(`| ${row.join(" | ")} |`);
+	}
+	if (items.length > maxItems) lines.push("", `_Showing ${maxItems} of ${items.length} items_`);
+	lines.push("");
+	return lines.join("\n");
+}
+/**
+* Generate a markdown list from array data.
+* Uses summaryFields to create concise list items.
+*/
+function schemaToMarkdownList(schema, items, options = {}) {
+	const { maxItems = 50, summaryFields, includeFields, excludeFields = [] } = options;
+	const fields = getFieldMeta(schema, includeFields, excludeFields);
+	const displayFields = summaryFields ? fields.filter((f) => summaryFields.includes(f.name)) : fields.slice(0, 3);
+	if (displayFields.length === 0 || items.length === 0) return "_No data available_\n";
+	const limitedItems = items.slice(0, maxItems);
+	const lines = [];
+	for (const item of limitedItems) {
+		const primaryValue = formatCellValue(getFieldValue(item, displayFields[0]?.name ?? "id"));
+		const secondaryValues = displayFields.slice(1).map((f) => `${f.label}: ${formatCellValue(getFieldValue(item, f.name))}`).join(" · ");
+		const itemLine = secondaryValues ? `- **${primaryValue}** (${secondaryValues})` : `- **${primaryValue}**`;
+		lines.push(itemLine);
+	}
+	if (items.length > maxItems) lines.push("", `_Showing ${maxItems} of ${items.length} items_`);
+	lines.push("");
+	return lines.join("\n");
+}
+/**
+* Generate a markdown detail view (key-value pairs) from object data.
+*/
+function schemaToMarkdownDetail(schema, item, options = {}) {
+	const { includeFields, excludeFields = [], maxDepth = 2 } = options;
+	if (item === null || typeof item !== "object") return "_No data available_\n";
+	const fields = getFieldMeta(schema, includeFields, excludeFields);
+	if (fields.length === 0) return "_No fields to display_\n";
+	const lines = [];
+	for (const field of fields) {
+		const formattedValue = formatDetailValue(getFieldValue(item, field.name), maxDepth, 0);
+		lines.push(`**${field.label}:** ${formattedValue}`);
+	}
+	lines.push("");
+	return lines.join("\n");
+}
+/**
+* Generate markdown summary statistics for numeric fields in array data.
+*/
+function schemaToMarkdownSummary(items, options = {}) {
+	const { numericFields = [], countByField } = options;
+	const lines = [];
+	lines.push(`**Total Items:** ${items.length}`);
+	for (const fieldName of numericFields) {
+		const values = items.map((item) => getFieldValue(item, fieldName)).filter((v) => typeof v === "number");
+		if (values.length > 0) {
+			const sum = values.reduce((a, b) => a + b, 0);
+			const avg = sum / values.length;
+			const min = Math.min(...values);
+			const max = Math.max(...values);
+			lines.push(`**${formatFieldName(fieldName)}:** Sum: ${formatNumber(sum)}, Avg: ${formatNumber(avg)}, Min: ${formatNumber(min)}, Max: ${formatNumber(max)}`);
+		}
+	}
+	if (countByField) {
+		const counts = {};
+		for (const item of items) {
+			const value = String(getFieldValue(item, countByField) ?? "Unknown");
+			counts[value] = (counts[value] ?? 0) + 1;
+		}
+		lines.push("", `**By ${formatFieldName(countByField)}:**`);
+		for (const [value, count] of Object.entries(counts)) lines.push(`- ${value}: ${count}`);
+	}
+	lines.push("");
+	return lines.join("\n");
+}
+/**
+* Get field metadata from schema, applying include/exclude filters
+*/
+function getFieldMeta(schema, includeFields, excludeFields = []) {
+	if (!isSchemaModel(schema)) return [];
+	const schemaFields = schema.config.fields;
+	return Object.keys(schemaFields).filter((name) => {
+		if (excludeFields.includes(name)) return false;
+		if (includeFields && !includeFields.includes(name)) return false;
+		return true;
+	}).map((name) => {
+		const fieldConfig = schemaFields[name];
+		const isNested = Boolean(fieldConfig?.type && typeof fieldConfig.type === "object" && "config" in fieldConfig.type && typeof fieldConfig.type.config?.fields === "object");
+		return {
+			name,
+			label: formatFieldName(name),
+			isOptional: fieldConfig?.isOptional ?? false,
+			isArray: fieldConfig?.isArray === true,
+			isNested
+		};
+	});
+}
+/**
+* Get value from object by field name (supports nested paths)
+*/
+function getFieldValue(item, fieldName) {
+	if (item === null || typeof item !== "object") return void 0;
+	const obj = item;
+	if (fieldName.includes(".")) {
+		const parts = fieldName.split(".");
+		let current = obj;
+		for (const part of parts) {
+			if (current === null || typeof current !== "object") return void 0;
+			current = current[part];
+		}
+		return current;
+	}
+	return obj[fieldName];
+}
+/**
+* Format a value for table cell display
+*/
+function formatCellValue(value) {
+	if (value === null || value === void 0) return "-";
+	if (typeof value === "boolean") return value ? "✓" : "✗";
+	if (typeof value === "number") return formatNumber(value);
+	if (value instanceof Date) return formatDate(value);
+	if (typeof value === "string" && isISODate(value)) return formatDate(new Date(value));
+	if (Array.isArray(value)) return `[${value.length} items]`;
+	if (typeof value === "object") return "[Object]";
+	const str = String(value);
+	return str.length > 50 ? `${str.slice(0, 47)}...` : str.replace(/\|/g, "\\|");
+}
+/**
+* Format a value for detail view (allows more space)
+*/
+function formatDetailValue(value, maxDepth, currentDepth) {
+	if (value === null || value === void 0) return "_none_";
+	if (typeof value === "boolean") return value ? "Yes" : "No";
+	if (typeof value === "number") return formatNumber(value);
+	if (value instanceof Date) return formatDate(value);
+	if (typeof value === "string" && isISODate(value)) return formatDate(new Date(value));
+	if (Array.isArray(value)) {
+		if (value.length === 0) return "_empty list_";
+		if (currentDepth >= maxDepth) return `[${value.length} items]`;
+		if (value.length <= 5 && value.every((v) => typeof v !== "object")) return value.map((v) => formatCellValue(v)).join(", ");
+		return `[${value.length} items]`;
+	}
+	if (typeof value === "object") {
+		if (currentDepth >= maxDepth) return "[Object]";
+		return `{${Object.keys(value).length} fields}`;
+	}
+	return String(value);
+}
+/**
+* Format field name to human-readable label
+*/
+function formatFieldName(name) {
+	return name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/_/g, " ").replace(/^\w/, (c) => c.toUpperCase());
+}
+/**
+* Format number with locale-aware formatting
+*/
+function formatNumber(value) {
+	if (Math.abs(value) >= 1e3) return new Intl.NumberFormat("en-US", { maximumFractionDigits: 2 }).format(value);
+	if (Number.isInteger(value)) return String(value);
+	return value.toFixed(2);
+}
+/**
+* Format date to readable string
+*/
+function formatDate(date) {
+	return date.toLocaleDateString("en-US", {
+		year: "numeric",
+		month: "short",
+		day: "numeric"
+	});
+}
+/**
+* Check if string is ISO date format
+*/
+function isISODate(str) {
+	if (!/^\d{4}-\d{2}-\d{2}/.test(str)) return false;
+	const date = new Date(str);
+	return !isNaN(date.getTime());
+}
+
+//#endregion
+export { schemaToMarkdown, schemaToMarkdownDetail, schemaToMarkdownList, schemaToMarkdownSummary, schemaToMarkdownTable };

package/dist/server/contracts-adapter-hydration.d.ts

@@ -0,0 +1,15 @@
+import { ResourceRegistry } from "../resources.js";
+
+//#region src/server/contracts-adapter-hydration.d.ts
+interface ReturnsDecl {
+  isList: boolean;
+  inner: string;
+}
+declare function parseReturns(returnsLike: string): ReturnsDecl;
+declare function hydrateResourceIfNeeded(resources: ResourceRegistry | undefined, result: unknown, opts: {
+  template?: string;
+  varName?: string;
+  returns: ReturnsDecl;
+}): Promise<unknown>;
+//#endregion
+export { ReturnsDecl, hydrateResourceIfNeeded, parseReturns };

package/dist/server/contracts-adapter-hydration.js

@@ -0,0 +1,41 @@
+//#region src/server/contracts-adapter-hydration.ts
+function parseReturns(returnsLike) {
+	if (!returnsLike) return {
+		isList: false,
+		inner: "JSON"
+	};
+	const trimmed = String(returnsLike).trim();
+	if (trimmed.startsWith("[") && trimmed.endsWith("]")) return {
+		isList: true,
+		inner: trimmed.slice(1, -1).trim()
+	};
+	return {
+		isList: false,
+		inner: trimmed
+	};
+}
+async function hydrateResourceIfNeeded(resources, result, opts) {
+	if (!resources || !opts.template) return result;
+	const varName = opts.varName ?? "id";
+	const hydrateOne = async (item) => {
+		if (item && typeof item === "object" && varName in item) {
+			const key = String(item[varName]);
+			const uri = (opts.template ?? "").replace("{id}", key);
+			const match = resources.match(uri);
+			if (match) {
+				const resolved = await match.tmpl.resolve(match.params, {});
+				try {
+					return JSON.parse(String(resolved.data || "null"));
+				} catch {
+					return resolved.data;
+				}
+			}
+		}
+		return item;
+	};
+	if (opts.returns.isList && Array.isArray(result)) return await Promise.all(result.map((x) => hydrateOne(x)));
+	return await hydrateOne(result);
+}
+
+//#endregion
+export { hydrateResourceIfNeeded, parseReturns };

package/dist/server/contracts-adapter-input.d.ts

@@ -0,0 +1,9 @@
+import { AnySchemaModel } from "@contractspec/lib.schema";
+import { SchemaTypes } from "@pothos/core";
+
+//#region src/server/contracts-adapter-input.d.ts
+declare function createInputTypeBuilder<T extends SchemaTypes>(builder: PothosSchemaTypes.SchemaBuilder<T>): {
+  buildInputFieldArgs: (model: AnySchemaModel | null) => null;
+};
+//#endregion
+export { createInputTypeBuilder };

package/dist/server/contracts-adapter-input.js

@@ -0,0 +1,83 @@
+import { isSchemaModel } from "@contractspec/lib.schema";
+
+//#region src/server/contracts-adapter-input.ts
+function isFieldType(x) {
+	return typeof x?.getPothos === "function";
+}
+function isEnumType(x) {
+	return typeof x?.getEnumValues === "function" && typeof x?.getPothos === "function";
+}
+function mapScalarName(name) {
+	if (name === "Boolean_unsecure") return "Boolean";
+	if (name === "ID_unsecure") return "ID";
+	if (name === "String_unsecure") return "String";
+	if (name === "Int_unsecure") return "Int";
+	if (name === "Float_unsecure") return "Float";
+	return name;
+}
+function createInputTypeBuilder(builder) {
+	const inputTypeCache = /* @__PURE__ */ new Map();
+	const enumTypeCache = /* @__PURE__ */ new Set();
+	function registerEnumsForModel(model) {
+		const entries = Object.entries(model.config.fields);
+		for (const [, field] of entries) {
+			const fieldType = field.type;
+			if (isSchemaModel(fieldType)) registerEnumsForModel(fieldType);
+			else if (isEnumType(field.type)) {
+				const enumObj = field.type;
+				const name = enumObj.getName?.() ?? enumObj.getPothos().name;
+				if (!enumTypeCache.has(name)) {
+					builder.enumType(name, { values: enumObj.getEnumValues() });
+					enumTypeCache.add(name);
+				}
+			}
+		}
+	}
+	function ensureInputTypeForModel(model) {
+		const typeName = String(model.config?.name ?? "Input");
+		const cached = inputTypeCache.get(typeName);
+		if (cached) return cached;
+		registerEnumsForModel(model);
+		const created = builder.inputType(model.getPothosInput(), { fields: (t) => {
+			const entries = Object.entries(model.config.fields);
+			const acc = {};
+			for (const [key, field] of entries) {
+				const fieldType = field.type;
+				if (isSchemaModel(fieldType)) {
+					const nested = ensureInputTypeForModel(fieldType);
+					const typeRef = field.isArray ? [nested] : nested;
+					acc[key] = t.field({
+						type: typeRef,
+						required: !field.isOptional
+					});
+				} else if (isFieldType(field.type)) {
+					const typeName$1 = mapScalarName(String(field.type.getPothos().name));
+					const typeRef = field.isArray ? [typeName$1] : typeName$1;
+					acc[key] = t.field({
+						type: typeRef,
+						required: !field.isOptional
+					});
+				} else {
+					const typeRef = field.isArray ? ["JSON"] : "JSON";
+					acc[key] = t.field({
+						type: typeRef,
+						required: !field.isOptional
+					});
+				}
+			}
+			return acc;
+		} });
+		inputTypeCache.set(typeName, created);
+		return created;
+	}
+	function buildInputFieldArgs(model) {
+		if (!model) return null;
+		if (!isSchemaModel(model)) return null;
+		if (!model.config?.fields || Object.keys(model.config.fields).length === 0) return null;
+		return ensureInputTypeForModel(model);
+	}
+	return { buildInputFieldArgs };
+}
+
+//#endregion
+export { createInputTypeBuilder };

package/dist/server/graphql-pothos.d.ts

@@ -0,0 +1,31 @@
+import { ResourceRegistry } from "../resources.js";
+import { OperationSpecRegistry } from "../operations/registry.js";
+import "@pothos/plugin-prisma";
+import "@pothos/plugin-complexity";
+import "@pothos/plugin-relay";
+import "@pothos/plugin-dataloader";
+import "@pothos/plugin-tracing";
+import { SchemaTypes } from "@pothos/core";
+
+//#region src/server/graphql-pothos.d.ts
+
+/**
+ * Registers all ContractSpecs from a OperationSpecRegistry onto a Pothos SchemaBuilder.
+ *
+ * This adapter:
+ * 1. Discovers output types from specs and registers them as Pothos object types.
+ * 2. Maps `ContractSpec` (OperationSpec) inputs to Pothos input types.
+ * 3. Mounts `query` specs as `Query` fields and `command` specs as `Mutation` fields.
+ * 4. Wraps the resolver to:
+ *    - Enforce auth policies (basic check).
+ *    - Build a `HandlerCtx`.
+ *    - Execute via `OperationSpecRegistry`.
+ *    - Hydrate resource references if applicable.
+ *
+ * @param builder - The Pothos SchemaBuilder instance.
+ * @param reg - The OperationSpecRegistry containing operations.
+ * @param resources - (Optional) ResourceRegistry for hydrating resource references.
+ */
+declare function registerContractsOnBuilder<T extends SchemaTypes>(builder: PothosSchemaTypes.SchemaBuilder<T>, reg: OperationSpecRegistry, resources?: ResourceRegistry): void;
+//#endregion
+export { registerContractsOnBuilder };