@lssm/lib.contracts 1.41.1 → 1.42.2

package/dist/regenerator/types.d.ts

@@ -0,0 +1,107 @@
+import { TelemetrySpec } from "../telemetry/spec.js";
+import { AppBlueprintSpec, TenantAppConfig } from "../app-config/spec.js";
+import { ResolvedAppConfig } from "../app-config/runtime.js";
+
+//#region src/regenerator/types.d.ts
+type RegeneratorSignal = TelemetrySignalEnvelope | ErrorSignalEnvelope | BehaviorSignalEnvelope;
+interface TelemetrySignalEnvelope {
+  type: 'telemetry';
+  contextId: string;
+  signal: TelemetrySignal;
+}
+interface TelemetrySignal {
+  eventName: string;
+  eventVersion: number;
+  count: number;
+  windowStart: Date;
+  windowEnd: Date;
+  anomalyScore?: number;
+  classification?: 'normal' | 'warning' | 'critical';
+  metadata?: Record<string, unknown>;
+  telemetrySpec?: TelemetrySpec;
+}
+interface ErrorSignalEnvelope {
+  type: 'error';
+  contextId: string;
+  signal: ErrorSignal;
+}
+interface ErrorSignal {
+  id: string;
+  classification: 'runtime' | 'policy' | 'workflow' | 'unknown';
+  message: string;
+  occurredAt: Date;
+  count: number;
+  metadata?: Record<string, unknown>;
+}
+interface BehaviorSignalEnvelope {
+  type: 'behavior';
+  contextId: string;
+  signal: BehaviorSignal;
+}
+interface BehaviorSignal {
+  feature: string;
+  metric: 'usage' | 'conversion' | 'latency' | 'custom';
+  value: number;
+  baseline?: number;
+  windowStart: Date;
+  windowEnd: Date;
+  metadata?: Record<string, unknown>;
+}
+interface SpecChangeProposal {
+  id: string;
+  title: string;
+  summary: string;
+  confidence: ProposalConfidence;
+  rationale: string[];
+  target: ProposalTarget;
+  diff?: string;
+  actions: ProposalAction[];
+  blockers?: ProposalBlocker[];
+  createdAt: Date;
+  signalIds: string[];
+}
+type ProposalConfidence = 'low' | 'medium' | 'high';
+interface ProposalTarget {
+  specType: 'workflow' | 'capability' | 'policy' | 'dataView' | 'telemetry' | 'experiment' | 'theme' | 'unknown';
+  reference: {
+    key: string;
+    version?: number;
+  };
+  tenantScoped?: boolean;
+}
+type ProposalAction = {
+  kind: 'update_blueprint';
+  summary: string;
+} | {
+  kind: 'update_tenant_config';
+  summary: string;
+} | {
+  kind: 'run_tests';
+  tests: string[];
+} | {
+  kind: 'run_migrations';
+  migrations: string[];
+} | {
+  kind: 'trigger_regeneration';
+  summary?: string;
+};
+interface ProposalBlocker {
+  description: string;
+  kind: 'missing_context' | 'insufficient_data' | 'user_feedback' | 'manual_review';
+}
+interface RegenerationContext {
+  id: string;
+  blueprint: AppBlueprintSpec;
+  tenantConfig: TenantAppConfig;
+  resolved: ResolvedAppConfig;
+}
+interface RegenerationRule {
+  readonly id: string;
+  readonly description: string;
+  evaluate(context: RegenerationContext, signals: RegeneratorSignal[]): Promise<SpecChangeProposal[]>;
+}
+interface ProposalSink {
+  submit(context: RegenerationContext, proposal: SpecChangeProposal): Promise<void>;
+}
+//#endregion
+export { BehaviorSignal, BehaviorSignalEnvelope, ErrorSignal, ErrorSignalEnvelope, ProposalAction, ProposalBlocker, ProposalConfidence, ProposalSink, ProposalTarget, RegenerationContext, RegenerationRule, RegeneratorSignal, SpecChangeProposal, TelemetrySignal, TelemetrySignalEnvelope };

package/dist/regenerator/utils.d.ts

@@ -0,0 +1,9 @@
+import { BehaviorSignal, BehaviorSignalEnvelope, ErrorSignal, ErrorSignalEnvelope, TelemetrySignal, TelemetrySignalEnvelope } from "./types.js";
+
+//#region src/regenerator/utils.d.ts
+type Clock = () => Date;
+declare function telemetryToEnvelope(contextId: string, signal: TelemetrySignal, clock: Clock): TelemetrySignalEnvelope;
+declare function errorToEnvelope(contextId: string, signal: ErrorSignal, clock: Clock): ErrorSignalEnvelope;
+declare function behaviorToEnvelope(contextId: string, signal: BehaviorSignal, clock: Clock): BehaviorSignalEnvelope;
+//#endregion
+export { behaviorToEnvelope, errorToEnvelope, telemetryToEnvelope };

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-utils.d.ts

@@ -0,0 +1,106 @@
+import { Stability } from "./ownership.js";
+
+//#region src/registry-utils.d.ts
+
+/**
+ * Filter criteria for registry items.
+ * All criteria are optional and combined with AND logic.
+ */
+interface RegistryFilter {
+  /** Filter by tags (item must have at least one matching tag) */
+  tags?: string[];
+  /** Filter by owners (item must have at least one matching owner) */
+  owners?: string[];
+  /** Filter by stability levels */
+  stability?: Stability[];
+  /** Filter by domain (first segment of name) */
+  domain?: string;
+  /** Filter by key pattern (glob or regex) */
+  keyPattern?: string;
+}
+/**
+ * Item with standard metadata for filtering.
+ */
+interface FilterableItem {
+  meta: {
+    key?: string;
+    tags?: string[];
+    owners?: string[];
+    stability?: Stability;
+    domain?: string;
+  };
+}
+/**
+ * Grouping key function type.
+ */
+type GroupKeyFn<T> = (item: T) => string;
+/**
+ * Grouped items result.
+ */
+interface GroupedItems<T> {
+  key: string;
+  items: T[];
+}
+/**
+ * Pre-built grouping strategies for common use cases.
+ */
+declare const GroupingStrategies: {
+  /**
+   * Group by first tag.
+   */
+  byTag: <T extends FilterableItem>(item: T) => string;
+  /**
+   * Group by all tags (item appears in multiple groups).
+   */
+  byAllTags: <T extends FilterableItem>(item: T) => string[];
+  /**
+   * Group by first owner.
+   */
+  byOwner: <T extends FilterableItem>(item: T) => string;
+  /**
+   * Group by domain (first segment of name).
+   */
+  byDomain: <T extends FilterableItem>(item: T) => string;
+  /**
+   * Group by stability level.
+   */
+  byStability: <T extends FilterableItem>(item: T) => string;
+  /**
+   * Create URL path grouping strategy with configurable depth.
+   */
+  byUrlPath: (level: number) => (item: {
+    path?: string;
+  }) => string;
+};
+/**
+ * Filter items by criteria.
+ * All criteria are combined with AND logic.
+ */
+declare function filterBy<T extends FilterableItem>(items: T[], filter: RegistryFilter): T[];
+/**
+ * Group items by key function.
+ */
+declare function groupBy<T>(items: T[], keyFn: GroupKeyFn<T>): Map<string, T[]>;
+/**
+ * Group items by key function, returning array format.
+ */
+declare function groupByToArray<T>(items: T[], keyFn: GroupKeyFn<T>): GroupedItems<T>[];
+/**
+ * Group items where one item can belong to multiple groups.
+ * Useful for byAllTags grouping.
+ */
+declare function groupByMultiple<T>(items: T[], keysFn: (item: T) => string[]): Map<string, T[]>;
+/**
+ * Get unique tags from a collection of items.
+ */
+declare function getUniqueTags<T extends FilterableItem>(items: T[]): string[];
+/**
+ * Get unique owners from a collection of items.
+ */
+declare function getUniqueOwners<T extends FilterableItem>(items: T[]): string[];
+/**
+ * Get unique domains from a collection of items.
+ */
+declare function getUniqueDomains<T extends FilterableItem>(items: T[]): string[];
+//#endregion
+export { FilterableItem, GroupKeyFn, GroupedItems, GroupingStrategies, RegistryFilter, filterBy, getUniqueDomains, getUniqueOwners, getUniqueTags, groupBy, groupByMultiple, groupByToArray };

package/dist/registry-utils.js

@@ -0,0 +1,122 @@
+import { __esmMin, __exportAll } from "./_virtual/rolldown_runtime.js";
+
+//#region src/registry-utils.ts
+var registry_utils_exports = /* @__PURE__ */ __exportAll({
+	GroupingStrategies: () => GroupingStrategies,
+	filterBy: () => filterBy,
+	getUniqueDomains: () => getUniqueDomains,
+	getUniqueOwners: () => getUniqueOwners,
+	getUniqueTags: () => getUniqueTags,
+	groupBy: () => groupBy,
+	groupByMultiple: () => groupByMultiple,
+	groupByToArray: () => groupByToArray
+});
+/**
+* Filter items by criteria.
+* All criteria are combined with AND logic.
+*/
+function filterBy(items, filter) {
+	return items.filter((item) => {
+		if (filter.tags?.length) {
+			if (!filter.tags.some((tag) => item.meta.tags?.includes(tag))) return false;
+		}
+		if (filter.owners?.length) {
+			if (!filter.owners.some((owner) => item.meta.owners?.includes(owner))) return false;
+		}
+		if (filter.stability?.length) {
+			if (!filter.stability.includes(item.meta.stability ?? "stable")) return false;
+		}
+		if (filter.domain) {
+			if (GroupingStrategies.byDomain(item) !== filter.domain) return false;
+		}
+		if (filter.keyPattern) {
+			const name = item.meta.key ?? item.meta.key ?? "";
+			const pattern = filter.keyPattern.replace(/\*/g, ".*").replace(/\?/g, ".");
+			if (!new RegExp(`^${pattern}$`, "i").test(name)) return false;
+		}
+		return true;
+	});
+}
+/**
+* Group items by key function.
+*/
+function groupBy(items, keyFn) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const key = keyFn(item);
+		const existing = groups.get(key);
+		if (existing) existing.push(item);
+		else groups.set(key, [item]);
+	}
+	return groups;
+}
+/**
+* Group items by key function, returning array format.
+*/
+function groupByToArray(items, keyFn) {
+	const map = groupBy(items, keyFn);
+	return Array.from(map.entries()).map(([key, items$1]) => ({
+		key,
+		items: items$1
+	}));
+}
+/**
+* Group items where one item can belong to multiple groups.
+* Useful for byAllTags grouping.
+*/
+function groupByMultiple(items, keysFn) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const keys = keysFn(item);
+		for (const key of keys) {
+			const existing = groups.get(key);
+			if (existing) existing.push(item);
+			else groups.set(key, [item]);
+		}
+	}
+	return groups;
+}
+/**
+* Get unique tags from a collection of items.
+*/
+function getUniqueTags(items) {
+	const tags = /* @__PURE__ */ new Set();
+	for (const item of items) for (const tag of item.meta.tags ?? []) tags.add(tag);
+	return Array.from(tags).sort();
+}
+/**
+* Get unique owners from a collection of items.
+*/
+function getUniqueOwners(items) {
+	const owners = /* @__PURE__ */ new Set();
+	for (const item of items) for (const owner of item.meta.owners ?? []) owners.add(owner);
+	return Array.from(owners).sort();
+}
+/**
+* Get unique domains from a collection of items.
+*/
+function getUniqueDomains(items) {
+	const domains = /* @__PURE__ */ new Set();
+	for (const item of items) domains.add(GroupingStrategies.byDomain(item));
+	return Array.from(domains).sort();
+}
+var GroupingStrategies;
+var init_registry_utils = __esmMin(() => {
+	GroupingStrategies = {
+		byTag: (item) => item.meta.tags?.[0] ?? "untagged",
+		byAllTags: (item) => item.meta.tags?.length ? item.meta.tags : ["untagged"],
+		byOwner: (item) => item.meta.owners?.[0] ?? "unowned",
+		byDomain: (item) => {
+			return (item.meta.key ?? item.meta.key ?? "").split(".")[0] ?? "default";
+		},
+		byStability: (item) => item.meta.stability ?? "stable",
+		byUrlPath: (level) => (item) => {
+			if (!item.path) return "root";
+			return item.path.split("/").filter(Boolean).slice(0, level).join("/") || "root";
+		}
+	};
+});
+
+//#endregion
+init_registry_utils();
+export { GroupingStrategies, filterBy, getUniqueDomains, getUniqueOwners, getUniqueTags, groupBy, groupByMultiple, groupByToArray, init_registry_utils, registry_utils_exports };

package/dist/registry.d.ts

@@ -0,0 +1,30 @@
+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;
+  private items;
+  protected constructor(contractType: ContractType, items?: SpecContract[]);
+  register(p: SpecContract): this;
+  list(): SpecContract[];
+  get(key: string, version?: number): SpecContract | undefined;
+  /** 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

@@ -1 +1,58 @@
-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 { filterBy, getUniqueTags, groupBy, init_registry_utils } from "./registry-utils.js";
+
+//#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;
+	}
+	list() {
+		return [...this.items.values()];
+	}
+	get(key, version) {
+		if (version != null) return this.items.get(`${key}.v${version}`);
+		let candidate;
+		let max = -Infinity;
+		for (const [k, p] of this.items.entries()) {
+			if (!k.startsWith(`${key}.v`)) continue;
+			if (p.meta.version > max) {
+				max = p.meta.version;
+				candidate = p;
+			}
+		}
+		return candidate;
+	}
+	/** 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$1 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$1.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$1.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$1.ZodType>(spec: ResourceTemplateSpec<I>): ResourceTemplateSpec<I>;
+declare class ResourceRegistry {
+  private templates;
+  register<I extends z$1.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

@@ -1 +1,50 @@
-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) => {
+				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 "@lssm/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 };