@lssm/lib.contracts 0.0.0-canary-20251217063201 → 0.0.0-canary-20251217072406

package/dist/regenerator/service.js

@@ -1 +1,92 @@
-import{behaviorToEnvelope as e,errorToEnvelope as t,telemetryToEnvelope as n}from"./utils.js";import{setTimeout as r}from"node:timers/promises";var i=class{contexts;lastPoll=new Map;timer;running=!1;pollInterval;batchDuration;clock;constructor(e){if(this.options=e,this.contexts=new Map(e.contexts.map(e=>[e.id,e])),this.pollInterval=e.pollIntervalMs??6e4,this.batchDuration=e.batchDurationMs??3e5,this.clock=e.clock??(()=>new Date),this.options.rules.length===0)throw Error(`RegeneratorService requires at least one rule`)}start(){this.running||(this.running=!0,this.tick(),this.timer=setInterval(()=>{this.tick()},this.pollInterval))}stop(){this.running&&(this.running=!1,this.timer&&=(clearInterval(this.timer),void 0))}async runOnce(){await this.tick()}async tick(){let e=this.clock(),t=new Date(e.getTime()-this.batchDuration);for(let n of this.contexts.values()){let r=this.lastPoll.get(n.id)??t;await this.evaluateContext(n,r,e),this.lastPoll.set(n.id,e)}}async evaluateContext(e,t,n){let r=await this.collectSignals(e,t,n);if(r.length!==0)for(let t of this.options.rules){let n=[];try{n=await t.evaluate(e,r)}catch(e){console.error(`[regenerator] rule ${t.id} failed`,e instanceof Error?e:Error(String(e)));continue}await this.flushProposals(e,n)}}async collectSignals(r,i,a){let o=[],{adapters:s}=this.options;if(s.telemetry){let e=await s.telemetry.pollTelemetry(r,i,a);o.push(...e.map(e=>n(r.id,e,this.clock)))}if(s.errors){let e=await s.errors.pollErrors(r,i,a);o.push(...e.map(e=>t(r.id,e,this.clock)))}if(s.behavior){let t=await s.behavior.pollBehavior(r,i,a);o.push(...t.map(t=>e(r.id,t,this.clock)))}return o}async flushProposals(e,t){for(let n of t)n.signalIds.length!==0&&(await this.options.sink.submit(e,n),t.length>10&&await r(0))}};export{i as RegeneratorService};
+import { behaviorToEnvelope, errorToEnvelope, telemetryToEnvelope } from "./utils.js";
+import { setTimeout } from "node:timers/promises";
+
+//#region src/regenerator/service.ts
+const DEFAULT_POLL_INTERVAL = 6e4;
+const DEFAULT_BATCH_DURATION = 5 * 6e4;
+var RegeneratorService = class {
+	contexts;
+	lastPoll = /* @__PURE__ */ new Map();
+	timer;
+	running = false;
+	pollInterval;
+	batchDuration;
+	clock;
+	constructor(options) {
+		this.options = options;
+		this.contexts = new Map(options.contexts.map((ctx) => [ctx.id, ctx]));
+		this.pollInterval = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL;
+		this.batchDuration = options.batchDurationMs ?? DEFAULT_BATCH_DURATION;
+		this.clock = options.clock ?? (() => /* @__PURE__ */ new Date());
+		if (this.options.rules.length === 0) throw new Error("RegeneratorService requires at least one rule");
+	}
+	start() {
+		if (this.running) return;
+		this.running = true;
+		this.tick();
+		this.timer = setInterval(() => {
+			this.tick();
+		}, this.pollInterval);
+	}
+	stop() {
+		if (!this.running) return;
+		this.running = false;
+		if (this.timer) {
+			clearInterval(this.timer);
+			this.timer = void 0;
+		}
+	}
+	async runOnce() {
+		await this.tick();
+	}
+	async tick() {
+		const now = this.clock();
+		const sinceDefault = new Date(now.getTime() - this.batchDuration);
+		for (const context of this.contexts.values()) {
+			const last = this.lastPoll.get(context.id) ?? sinceDefault;
+			await this.evaluateContext(context, last, now);
+			this.lastPoll.set(context.id, now);
+		}
+	}
+	async evaluateContext(context, since, until) {
+		const signals = await this.collectSignals(context, since, until);
+		if (signals.length === 0) return;
+		for (const rule of this.options.rules) {
+			let proposals = [];
+			try {
+				proposals = await rule.evaluate(context, signals);
+			} catch (error) {
+				console.error(`[regenerator] rule ${rule.id} failed`, error instanceof Error ? error : new Error(String(error)));
+				continue;
+			}
+			await this.flushProposals(context, proposals);
+		}
+	}
+	async collectSignals(context, since, until) {
+		const envelopes = [];
+		const { adapters } = this.options;
+		if (adapters.telemetry) {
+			const telemetrySignals = await adapters.telemetry.pollTelemetry(context, since, until);
+			envelopes.push(...telemetrySignals.map((signal) => telemetryToEnvelope(context.id, signal, this.clock)));
+		}
+		if (adapters.errors) {
+			const errorSignals = await adapters.errors.pollErrors(context, since, until);
+			envelopes.push(...errorSignals.map((signal) => errorToEnvelope(context.id, signal, this.clock)));
+		}
+		if (adapters.behavior) {
+			const behaviorSignals = await adapters.behavior.pollBehavior(context, since, until);
+			envelopes.push(...behaviorSignals.map((signal) => behaviorToEnvelope(context.id, signal, this.clock)));
+		}
+		return envelopes;
+	}
+	async flushProposals(context, proposals) {
+		for (const proposal of proposals) {
+			if (proposal.signalIds.length === 0) continue;
+			await this.options.sink.submit(context, proposal);
+			if (proposals.length > 10) await setTimeout(0);
+		}
+	}
+};
+
+//#endregion
+export { RegeneratorService };

package/dist/regenerator/sinks.js

@@ -1 +1,32 @@
-var e=class{constructor(e,t={}){this.executor=e,this.options=t}async submit(e,t){let n=this.options.dryRun??!1;try{let r=await this.executor.execute(e,t,{dryRun:n});this.options.logger?.info&&this.options.logger.info(`[regenerator] proposal executed`,{proposalId:t.id,contextId:e.id,status:r.status}),this.options.onResult&&await this.options.onResult({context:e,proposal:t,result:r})}catch(n){throw this.options.logger?.error&&this.options.logger.error(`[regenerator] proposal execution failed`,n instanceof Error?n:Error(String(n)),{proposalId:t.id,contextId:e.id}),n instanceof Error?n:Error(String(n))}}};export{e as ExecutorProposalSink};
+//#region src/regenerator/sinks.ts
+var ExecutorProposalSink = class {
+	constructor(executor, options = {}) {
+		this.executor = executor;
+		this.options = options;
+	}
+	async submit(context, proposal) {
+		const dryRun = this.options.dryRun ?? false;
+		try {
+			const result = await this.executor.execute(context, proposal, { dryRun });
+			if (this.options.logger?.info) this.options.logger.info("[regenerator] proposal executed", {
+				proposalId: proposal.id,
+				contextId: context.id,
+				status: result.status
+			});
+			if (this.options.onResult) await this.options.onResult({
+				context,
+				proposal,
+				result
+			});
+		} catch (error) {
+			if (this.options.logger?.error) this.options.logger.error("[regenerator] proposal execution failed", error instanceof Error ? error : new Error(String(error)), {
+				proposalId: proposal.id,
+				contextId: context.id
+			});
+			throw error instanceof Error ? error : new Error(String(error));
+		}
+	}
+};
+
+//#endregion
+export { ExecutorProposalSink };

package/dist/regenerator/utils.js

@@ -1 +1,51 @@
-function e(e,t,n){return{type:`telemetry`,contextId:e,signal:r(t,n)}}function t(e,t,n){return{type:`error`,contextId:e,signal:i(t,n)}}function n(e,t,n){return{type:`behavior`,contextId:e,signal:a(t,n)}}function r(e,t){return{...e,windowStart:o(e.windowStart,t),windowEnd:o(e.windowEnd,t)}}function i(e,t){return{...e,occurredAt:o(e.occurredAt,t)}}function a(e,t){return{...e,windowStart:o(e.windowStart,t),windowEnd:o(e.windowEnd,t)}}function o(e,t){if(e instanceof Date)return e;let n=new Date(e);return Number.isNaN(n.getTime())?t():n}export{n as behaviorToEnvelope,t as errorToEnvelope,e as telemetryToEnvelope};
+//#region src/regenerator/utils.ts
+function telemetryToEnvelope(contextId, signal, clock) {
+	return {
+		type: "telemetry",
+		contextId,
+		signal: normalizeTelemetryDates(signal, clock)
+	};
+}
+function errorToEnvelope(contextId, signal, clock) {
+	return {
+		type: "error",
+		contextId,
+		signal: normalizeErrorDates(signal, clock)
+	};
+}
+function behaviorToEnvelope(contextId, signal, clock) {
+	return {
+		type: "behavior",
+		contextId,
+		signal: normalizeBehaviorDates(signal, clock)
+	};
+}
+function normalizeTelemetryDates(signal, clock) {
+	return {
+		...signal,
+		windowStart: toDate(signal.windowStart, clock),
+		windowEnd: toDate(signal.windowEnd, clock)
+	};
+}
+function normalizeErrorDates(signal, clock) {
+	return {
+		...signal,
+		occurredAt: toDate(signal.occurredAt, clock)
+	};
+}
+function normalizeBehaviorDates(signal, clock) {
+	return {
+		...signal,
+		windowStart: toDate(signal.windowStart, clock),
+		windowEnd: toDate(signal.windowEnd, clock)
+	};
+}
+function toDate(value, clock) {
+	if (value instanceof Date) return value;
+	const parsed = new Date(value);
+	if (Number.isNaN(parsed.getTime())) return clock();
+	return parsed;
+}
+
+//#endregion
+export { behaviorToEnvelope, errorToEnvelope, telemetryToEnvelope };

package/dist/registry.js

@@ -1 +1,208 @@
-import{eventKey as e}from"./events.js";import{isEmitDeclRef as t}from"./spec.js";import{defaultDocRegistry as n,docId as r,registerDocBlocks as i}from"./docs/registry.js";function a(e,t){return`${e}.v${t}`}var o=class{specs=new Map;handlers=new Map;register(e){let t=a(e.meta.name,e.meta.version);if(this.specs.has(t))throw Error(`Duplicate spec ${t}`);return this.specs.set(t,e),this}bind(e,t){let n=a(e.meta.name,e.meta.version);if(!this.specs.has(n))throw Error(`Cannot bind; spec not found: ${n}`);if(this.handlers.has(n))throw Error(`Handler already bound for ${n}`);return this.handlers.set(n,t),this}getSpec(e,t){if(t!=null)return this.specs.get(a(e,t));let n,r=-1/0;for(let[t,i]of this.specs.entries())t.startsWith(`${e}.v`)&&i.meta.version>r&&(r=i.meta.version,n=i);return n}getHandler(e,t){let n=this.getSpec(e,t);if(n)return this.handlers.get(a(n.meta.name,n.meta.version))}listSpecs(){return[...this.specs.values()]}listBound(){let e=[];for(let[t,n]of this.specs.entries()){let r=this.handlers.get(t);r&&e.push({spec:n,handler:r})}return e}async execute(n,r,i,o){let s=this.getSpec(n,r);if(!s)throw Error(`Spec not found for ${n}${r?`.v${r}`:``}`);let c=await o.specVariantResolver?.resolve({name:s.meta.name,version:s.meta.version,kind:s.meta.kind},o)??s,l=a(c.meta.name,c.meta.version),u=this.handlers.get(l);if(!u){let e=a(s.meta.name,s.meta.version);u=this.handlers.get(e),l=e}if(!u)throw Error(`No handler bound for ${l}`);let d=c.io.input?.getZod().parse(i);if(o.decide){let[e,t]=c.meta.name.split(`.`),n=await o.decide({service:e,command:t,version:c.meta.version,actor:o.actor??`anonymous`,channel:o.channel,roles:o.roles,organizationId:o.organizationId,userId:o.userId,flags:[]});if(n.effect===`deny`)throw Error(`PolicyDenied: ${c.meta.name}.v${c.meta.version}`);if(n.rateLimit&&o.rateLimit){let e=n.rateLimit.key??`default`,t=n.rateLimit.rpm??60;await o.rateLimit(e,1,t)}}let f=new Map;if(c.sideEffects?.emits)for(let e of c.sideEffects.emits)t(e)?f.set(`${e.ref.name}.v${e.ref.version}`,e.ref.payload):f.set(`${e.name}.v${e.version}`,e.payload);let p=async(t,n,r)=>{let i=e(t,n),s=f.get(i);if(!s)throw Error(`UndeclaredEvent: ${i} not allowed by ${a(c.meta.name,c.meta.version)}`);let l=s.getZod().parse(r);await o.eventPublisher?.({name:t,version:n,payload:l,traceId:o.traceId})};o.appConfig&&(o.branding||=o.appConfig.branding,o.translation?o.translation.config||(o.translation={...o.translation,config:o.appConfig.translation}):o.translation={config:o.appConfig.translation});let m=o.telemetry,h=async(e,t)=>{if(!(!m||!e?.event))try{let n=e.properties?.(t)??{};await m.track(e.event.name,e.event.version??1,n,{tenantId:o.organizationId??void 0,organizationId:o.organizationId,userId:o.userId,actor:o.actor,channel:o.channel,metadata:o.traceId?{traceId:o.traceId}:void 0})}catch{}},g;try{g=await u(d,{...o,__emitGuard__:p})}catch(e){throw c.telemetry?.failure&&await h(c.telemetry.failure,{input:d??i,error:e}),e}c.telemetry?.success&&await h(c.telemetry.success,{input:d??i,output:g});let _=c.io.output;return _?.getZod?_.getZod().parse(g):g}};export{o as SpecRegistry,n as defaultDocRegistry,r as docId,a as opKey,i as registerDocBlocks};
+import { eventKey } from "./events.js";
+import { isEmitDeclRef } from "./spec.js";
+import { defaultDocRegistry, docId, registerDocBlocks } from "./docs/registry.js";
+
+//#region src/registry.ts
+/**
+* SpecRegistry:
+* - Registers ContractSpecs (unique by name+version)
+* - Binds runtime handlers to specs
+* - Provides lookup, iteration, and a safe execute() with validation/policy/enforcement
+*
+* Includes a minimal OpRegistry shim for backward-compat (deprecated).
+*/
+function opKey(name, version) {
+	return `${name}.v${version}`;
+}
+/**
+* In-memory registry for ContractSpecs and their bound handlers.
+* Provides validation, policy enforcement, and guarded event emission at execute time.
+*/
+var SpecRegistry = class {
+	specs = /* @__PURE__ */ new Map();
+	handlers = /* @__PURE__ */ new Map();
+	/**
+	* Registers a ContractSpec definition.
+	*
+	* @param spec - The contract specification to register.
+	* @returns The registry instance for chaining.
+	* @throws If a spec with the same name and version is already registered.
+	*/
+	register(spec) {
+		const key = opKey(spec.meta.name, spec.meta.version);
+		if (this.specs.has(key)) throw new Error(`Duplicate spec ${key}`);
+		this.specs.set(key, spec);
+		return this;
+	}
+	/**
+	* Binds a runtime handler implementation to a previously registered spec.
+	*
+	* @param spec - The spec to bind to.
+	* @param handler - The async function implementing the business logic.
+	* @returns The registry instance for chaining.
+	* @throws If the spec is not found or a handler is already bound.
+	*/
+	bind(spec, handler) {
+		const key = opKey(spec.meta.name, spec.meta.version);
+		if (!this.specs.has(key)) throw new Error(`Cannot bind; spec not found: ${key}`);
+		if (this.handlers.has(key)) throw new Error(`Handler already bound for ${key}`);
+		this.handlers.set(key, handler);
+		return this;
+	}
+	/**
+	* Retrieves a registered spec by name and version.
+	* If version is omitted, returns the highest version found.
+	*
+	* @param name - Operation name.
+	* @param version - (Optional) Specific version.
+	*/
+	getSpec(name, version) {
+		if (version != null) return this.specs.get(opKey(name, version));
+		let found;
+		let maxV = -Infinity;
+		for (const [k, s] of this.specs.entries()) {
+			if (!k.startsWith(`${name}.v`)) continue;
+			if (s.meta.version > maxV) {
+				maxV = s.meta.version;
+				found = s;
+			}
+		}
+		return found;
+	}
+	/**
+	* Retrieves the bound handler for a spec.
+	*/
+	getHandler(name, version) {
+		const spec = this.getSpec(name, version);
+		if (!spec) return void 0;
+		return this.handlers.get(opKey(spec.meta.name, spec.meta.version));
+	}
+	/** Iterate all registered specs. */
+	listSpecs() {
+		return [...this.specs.values()];
+	}
+	/** Iterate all bound operations (spec+handler). */
+	listBound() {
+		const out = [];
+		for (const [k, spec] of this.specs.entries()) {
+			const h = this.handlers.get(k);
+			if (h) out.push({
+				spec,
+				handler: h
+			});
+		}
+		return out;
+	}
+	/**
+	* Execute an operation by name/version with full runtime protections:
+	* 1. Validates input against Zod schema.
+	* 2. Enforces policy (Auth, RBAC, Rate Limits) via PDP.
+	* 3. Guards event emission to ensure only declared events are sent.
+	* 4. Validates output against Zod schema (if applicable).
+	* 5. Tracks telemetry (success/failure).
+	*
+	* @param name - Operation name.
+	* @param version - Operation version (optional, defaults to latest).
+	* @param rawInput - The raw input payload (e.g. from JSON body).
+	* @param ctx - The runtime context (actor, tenant, etc.).
+	*/
+	async execute(name, version, rawInput, ctx) {
+		const baseSpec = this.getSpec(name, version);
+		if (!baseSpec) throw new Error(`Spec not found for ${name}${version ? `.v${version}` : ""}`);
+		const spec = await ctx.specVariantResolver?.resolve({
+			name: baseSpec.meta.name,
+			version: baseSpec.meta.version,
+			kind: baseSpec.meta.kind
+		}, ctx) ?? baseSpec;
+		let key = opKey(spec.meta.name, spec.meta.version);
+		let handler = this.handlers.get(key);
+		if (!handler) {
+			const fallbackKey = opKey(baseSpec.meta.name, baseSpec.meta.version);
+			handler = this.handlers.get(fallbackKey);
+			key = fallbackKey;
+		}
+		if (!handler) throw new Error(`No handler bound for ${key}`);
+		const parsedInput = spec.io.input?.getZod().parse(rawInput);
+		if (ctx.decide) {
+			const [service, command] = spec.meta.name.split(".");
+			const decision = await ctx.decide({
+				service,
+				command,
+				version: spec.meta.version,
+				actor: ctx.actor ?? "anonymous",
+				channel: ctx.channel,
+				roles: ctx.roles,
+				organizationId: ctx.organizationId,
+				userId: ctx.userId,
+				flags: []
+			});
+			if (decision.effect === "deny") throw new Error(`PolicyDenied: ${spec.meta.name}.v${spec.meta.version}`);
+			if (decision.rateLimit && ctx.rateLimit) {
+				const key$1 = decision.rateLimit.key ?? "default";
+				const rpm = decision.rateLimit.rpm ?? 60;
+				await ctx.rateLimit(key$1, 1, rpm);
+			}
+		}
+		const allowedEvents = /* @__PURE__ */ new Map();
+		if (spec.sideEffects?.emits) for (const e of spec.sideEffects.emits) if (isEmitDeclRef(e)) allowedEvents.set(`${e.ref.name}.v${e.ref.version}`, e.ref.payload);
+		else allowedEvents.set(`${e.name}.v${e.version}`, e.payload);
+		const emitGuard = async (eventName, eventVersion, payload) => {
+			const key2 = eventKey(eventName, eventVersion);
+			const schema = allowedEvents.get(key2);
+			if (!schema) throw new Error(`UndeclaredEvent: ${key2} not allowed by ${opKey(spec.meta.name, spec.meta.version)}`);
+			const parsed = schema.getZod().parse(payload);
+			await ctx.eventPublisher?.({
+				name: eventName,
+				version: eventVersion,
+				payload: parsed,
+				traceId: ctx.traceId
+			});
+		};
+		if (ctx.appConfig) {
+			if (!ctx.branding) ctx.branding = ctx.appConfig.branding;
+			if (!ctx.translation) ctx.translation = { config: ctx.appConfig.translation };
+			else if (!ctx.translation.config) ctx.translation = {
+				...ctx.translation,
+				config: ctx.appConfig.translation
+			};
+		}
+		const telemetryContext = ctx.telemetry;
+		const trackTelemetry = async (trigger, details) => {
+			if (!telemetryContext || !trigger?.event) return;
+			try {
+				const props = trigger.properties?.(details) ?? {};
+				await telemetryContext.track(trigger.event.name, trigger.event.version ?? 1, props, {
+					tenantId: ctx.organizationId ?? void 0,
+					organizationId: ctx.organizationId,
+					userId: ctx.userId,
+					actor: ctx.actor,
+					channel: ctx.channel,
+					metadata: ctx.traceId ? { traceId: ctx.traceId } : void 0
+				});
+			} catch (_error) {}
+		};
+		let result;
+		try {
+			result = await handler(parsedInput, {
+				...ctx,
+				__emitGuard__: emitGuard
+			});
+		} catch (error) {
+			if (spec.telemetry?.failure) await trackTelemetry(spec.telemetry.failure, {
+				input: parsedInput ?? rawInput,
+				error
+			});
+			throw error;
+		}
+		if (spec.telemetry?.success) await trackTelemetry(spec.telemetry.success, {
+			input: parsedInput ?? rawInput,
+			output: result
+		});
+		const outputModel = spec.io.output;
+		if (outputModel?.getZod) return outputModel.getZod().parse(result);
+		return result;
+	}
+};
+
+//#endregion
+export { SpecRegistry, defaultDocRegistry, docId, opKey, registerDocBlocks };

package/dist/resources.js

@@ -1 +1,47 @@
-import"zod";function e(e){return e}var t=class{templates=[];register(e){return this.templates.push(e),this}listTemplates(){return[...this.templates]}match(e){for(let t of this.templates){let n=RegExp(`^`+t.meta.uriTemplate.replace(/\{[^}]+\}/g,`([^/]+)`)+`$`),r=e.match(n);if(!r)continue;let i=[...t.meta.uriTemplate.matchAll(/\{([^}]+)\}/g)].map(e=>e[1]),a={};return i.forEach((e,t)=>a[e]=decodeURIComponent(r[t+1])),{tmpl:t,params:a}}}};function n(e,t){return{kind:`resource_ref`,uriTemplate:e,varName:t.varName??`id`,graphQLType:t.graphQLType,many:t.many}}function r(e){let t=e;return!!t&&t.kind===`resource_ref`&&typeof t.uriTemplate==`string`}export{t as ResourceRegistry,e as defineResourceTemplate,r as isResourceRef,n as resourceRef};
+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) => params[n] = decodeURIComponent(m[i + 1]));
+			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/dist/EnumType.js

@@ -1 +1,2 @@
-import"zod";import"graphql";
+import "zod";
+import "graphql";

package/dist/schema/dist/FieldType.js

@@ -1 +1,49 @@
-import"zod";import{GraphQLScalarType as e}from"graphql";var t=class extends e{zodSchema;jsonSchemaDef;constructor(e){super(e),this.zodSchema=e.zod,this.jsonSchemaDef=e.jsonSchema}getZod(){return this.zodSchema}getPothos(){return this}getJson(){return typeof this.jsonSchemaDef==`function`?this.jsonSchemaDef():this.jsonSchemaDef}getJsonSchemaDef(){return this.jsonSchemaDef}getJsonSchema(){let e=t=>{let n=typeof t==`function`?t():t;if(Array.isArray(n))return n.map(t=>e(t));if(n&&typeof n==`object`){let t={};for(let[r,i]of Object.entries(n))t[r]=e(i);return t}return n};return e(this.getJson())}};export{t};
+import "zod";
+import { GraphQLScalarType } from "graphql";
+
+//#region ../schema/dist/FieldType.js
+/**
+* GraphQL scalar wrapper that carries zod and JSON Schema metadata.
+*
+* TInternal is the runtime representation; TExternal is the GraphQL output.
+*/
+var FieldType = class extends GraphQLScalarType {
+	zodSchema;
+	jsonSchemaDef;
+	constructor(config) {
+		super(config);
+		this.zodSchema = config.zod;
+		this.jsonSchemaDef = config.jsonSchema;
+	}
+	/** Return the attached zod schema for validation. */
+	getZod() {
+		return this.zodSchema;
+	}
+	/** GraphQL scalar instance usable by Pothos or vanilla GraphQL. */
+	getPothos() {
+		return this;
+	}
+	/** Return the JSON Schema (evaluates factory if provided). */
+	getJson() {
+		return typeof this.jsonSchemaDef === "function" ? this.jsonSchemaDef() : this.jsonSchemaDef;
+	}
+	getJsonSchemaDef() {
+		return this.jsonSchemaDef;
+	}
+	getJsonSchema() {
+		const deepResolve = (v) => {
+			const value = typeof v === "function" ? v() : v;
+			if (Array.isArray(value)) return value.map((item) => deepResolve(item));
+			if (value && typeof value === "object") {
+				const obj = {};
+				for (const [k, val] of Object.entries(value)) obj[k] = deepResolve(val);
+				return obj;
+			}
+			return value;
+		};
+		return deepResolve(this.getJson());
+	}
+};
+
+//#endregion
+export { FieldType };