@lssm/example.personalization 0.0.0-canary-20251217063201 → 0.0.0-canary-20251217072406

package/dist/libs/overlay-engine/dist/runtime.js

@@ -1 +1,53 @@
-import{e}from"./merger.js";var t=class{registry;audit;constructor(e){this.registry=e.registry,this.audit=e.audit}apply(t){let r=t.overlays??this.registry.forContext({capability:t.capability,workflow:t.workflow,dataView:t.dataView,presentation:t.presentation,operation:t.operation,tenantId:t.tenantId,role:t.role,userId:t.userId,device:t.device,tags:t.tags}),i=e(t.target,r,{strict:t.strict}),a=n(t);return r.forEach(e=>{this.audit?.({overlay:{overlayId:e.overlayId,version:e.version},context:a,timestamp:new Date().toISOString()})}),{target:i,overlaysApplied:r}}};function n(e){return{tenantId:e.tenantId,role:e.role,userId:e.userId,device:e.device,tags:e.tags}}export{t};
+import { applyOverlayModifications } from "./merger.js";
+
+//#region ../../libs/overlay-engine/dist/runtime.js
+var OverlayEngine = class {
+	registry;
+	audit;
+	constructor(options) {
+		this.registry = options.registry;
+		this.audit = options.audit;
+	}
+	apply(params) {
+		const overlays = params.overlays ?? this.registry.forContext({
+			capability: params.capability,
+			workflow: params.workflow,
+			dataView: params.dataView,
+			presentation: params.presentation,
+			operation: params.operation,
+			tenantId: params.tenantId,
+			role: params.role,
+			userId: params.userId,
+			device: params.device,
+			tags: params.tags
+		});
+		const merged = applyOverlayModifications(params.target, overlays, { strict: params.strict });
+		const context = extractContext(params);
+		overlays.forEach((overlay) => {
+			this.audit?.({
+				overlay: {
+					overlayId: overlay.overlayId,
+					version: overlay.version
+				},
+				context,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		});
+		return {
+			target: merged,
+			overlaysApplied: overlays
+		};
+	}
+};
+function extractContext(params) {
+	return {
+		tenantId: params.tenantId,
+		role: params.role,
+		userId: params.userId,
+		device: params.device,
+		tags: params.tags
+	};
+}
+
+//#endregion
+export { OverlayEngine };

package/dist/libs/overlay-engine/dist/signer.js

@@ -1 +1,45 @@
-import e from"fast-json-stable-stringify";import{constants as t,createPrivateKey as n,createPublicKey as r,sign as i}from"crypto";function a(e,a,c={}){let l=c.algorithm??`ed25519`,u=typeof a==`string`||Buffer.isBuffer(a)?n(a):a,d=Buffer.from(o(e),`utf8`),f;if(l===`ed25519`)f=i(null,d,u);else if(l===`rsa-pss-sha256`)f=i(`sha256`,d,{key:u,padding:t.RSA_PKCS1_PSS_PADDING,saltLength:32});else throw Error(`Unsupported overlay signature algorithm: ${l}`);let p=c.publicKey??r(u).export({format:`pem`,type:`spki`}).toString();return{...e,signature:{algorithm:l,signature:f.toString(`base64`),publicKey:p,keyId:c.keyId,issuedAt:s(c.issuedAt)??new Date().toISOString(),expiresAt:s(c.expiresAt),metadata:c.metadata}}}function o(t){let{signature:n,...r}=t;return e(r)}function s(e){if(e)return typeof e==`string`?new Date(e).toISOString():e.toISOString()}export{o as c,a as o};
+import stringify from "fast-json-stable-stringify";
+import { constants, createPrivateKey, createPublicKey, sign } from "crypto";
+
+//#region ../../libs/overlay-engine/dist/signer.js
+function signOverlay(spec, privateKey, options = {}) {
+	const algorithm = options.algorithm ?? "ed25519";
+	const keyObject = typeof privateKey === "string" || Buffer.isBuffer(privateKey) ? createPrivateKey(privateKey) : privateKey;
+	const payload = Buffer.from(canonicalizeOverlay(spec), "utf8");
+	let rawSignature;
+	if (algorithm === "ed25519") rawSignature = sign(null, payload, keyObject);
+	else if (algorithm === "rsa-pss-sha256") rawSignature = sign("sha256", payload, {
+		key: keyObject,
+		padding: constants.RSA_PKCS1_PSS_PADDING,
+		saltLength: 32
+	});
+	else throw new Error(`Unsupported overlay signature algorithm: ${algorithm}`);
+	const publicKey = options.publicKey ?? createPublicKey(keyObject).export({
+		format: "pem",
+		type: "spki"
+	}).toString();
+	return {
+		...spec,
+		signature: {
+			algorithm,
+			signature: rawSignature.toString("base64"),
+			publicKey,
+			keyId: options.keyId,
+			issuedAt: toIso(options.issuedAt) ?? (/* @__PURE__ */ new Date()).toISOString(),
+			expiresAt: toIso(options.expiresAt),
+			metadata: options.metadata
+		}
+	};
+}
+function canonicalizeOverlay(spec) {
+	const { signature, ...rest } = spec;
+	return stringify(rest);
+}
+function toIso(value) {
+	if (!value) return;
+	if (typeof value === "string") return new Date(value).toISOString();
+	return value.toISOString();
+}
+
+//#endregion
+export { canonicalizeOverlay, signOverlay };

package/dist/libs/overlay-engine/dist/spec.js

@@ -1 +1,7 @@
-function e(e){return e}export{e as t};
+//#region ../../libs/overlay-engine/dist/spec.js
+function defineOverlay(spec) {
+	return spec;
+}
+
+//#endregion
+export { defineOverlay };

package/dist/libs/overlay-engine/dist/validator.js

@@ -1 +1,93 @@
-const e=[`capability`,`workflow`,`dataView`,`presentation`,`operation`],t=e=>n(e);function n(t){let n=[];return t.overlayId?.trim()||n.push({code:`overlay.id`,message:`overlayId is required`,path:[`overlayId`]}),t.version?.trim()||n.push({code:`overlay.version`,message:`version is required`,path:[`version`]}),e.some(e=>{let n=t.appliesTo?.[e];return typeof n==`string`&&n.trim().length>0})||n.push({code:`overlay.target`,message:`Overlay must specify at least one target (capability, workflow, dataView, presentation, or operation).`,path:[`appliesTo`]}),t.modifications?.length?t.modifications.forEach((e,t)=>{r(e,[`modifications`,String(t)],n)}):n.push({code:`overlay.modifications.empty`,message:`Overlay must include at least one modification.`,path:[`modifications`]}),{valid:n.length===0,issues:n}}function r(e,t,n){let r=(e,r,i)=>{n.push({code:e,message:r,path:i?[...t,...i]:t})};switch(i(e)&&(e.field?.trim()||r(`overlay.mod.field`,`field is required for this modification`,[`field`])),e.type){case`renameLabel`:e.newLabel?.trim()||r(`overlay.mod.renameLabel.newLabel`,`newLabel is required`,[`newLabel`]);break;case`reorderFields`:{e.fields?.length||r(`overlay.mod.reorderFields.fields`,`fields list cannot be empty`,[`fields`]);let t=new Set;for(let n of e.fields??[]){if(!n?.trim()){r(`overlay.mod.reorderFields.fields.blank`,`fields entries must be non-empty`);break}if(t.has(n)){r(`overlay.mod.reorderFields.fields.duplicate`,`field "${n}" was listed multiple times`);break}t.add(n)}break}case`setDefault`:e.value===void 0&&r(`overlay.mod.setDefault.value`,`value is required`,[`value`]);break;case`addHelpText`:e.text?.trim()||r(`overlay.mod.addHelpText.text`,`text is required`,[`text`]);break;case`makeRequired`:case`hideField`:break;default:{let t=e;throw Error(`Unsupported overlay modification ${t?.type??`unknown`}`)}}}function i(e){return`field`in e}export{n,t};
+//#region ../../libs/overlay-engine/dist/validator.js
+const TARGET_KEYS = [
+	"capability",
+	"workflow",
+	"dataView",
+	"presentation",
+	"operation"
+];
+const defaultOverlayValidator = (spec) => validateOverlaySpec(spec);
+function validateOverlaySpec(spec) {
+	const issues = [];
+	if (!spec.overlayId?.trim()) issues.push({
+		code: "overlay.id",
+		message: "overlayId is required",
+		path: ["overlayId"]
+	});
+	if (!spec.version?.trim()) issues.push({
+		code: "overlay.version",
+		message: "version is required",
+		path: ["version"]
+	});
+	if (!TARGET_KEYS.some((key) => {
+		const value = spec.appliesTo?.[key];
+		return typeof value === "string" && value.trim().length > 0;
+	})) issues.push({
+		code: "overlay.target",
+		message: "Overlay must specify at least one target (capability, workflow, dataView, presentation, or operation).",
+		path: ["appliesTo"]
+	});
+	if (!spec.modifications?.length) issues.push({
+		code: "overlay.modifications.empty",
+		message: "Overlay must include at least one modification.",
+		path: ["modifications"]
+	});
+	else spec.modifications.forEach((mod, idx) => {
+		validateModification(mod, ["modifications", String(idx)], issues);
+	});
+	return {
+		valid: issues.length === 0,
+		issues
+	};
+}
+function validateModification(modification, path, issues) {
+	const push = (code, message, extraPath) => {
+		issues.push({
+			code,
+			message,
+			path: extraPath ? [...path, ...extraPath] : path
+		});
+	};
+	if (isFieldModification(modification)) {
+		if (!modification.field?.trim()) push("overlay.mod.field", "field is required for this modification", ["field"]);
+	}
+	switch (modification.type) {
+		case "renameLabel":
+			if (!modification.newLabel?.trim()) push("overlay.mod.renameLabel.newLabel", "newLabel is required", ["newLabel"]);
+			break;
+		case "reorderFields": {
+			if (!modification.fields?.length) push("overlay.mod.reorderFields.fields", "fields list cannot be empty", ["fields"]);
+			const seen = /* @__PURE__ */ new Set();
+			for (const field of modification.fields ?? []) {
+				if (!field?.trim()) {
+					push("overlay.mod.reorderFields.fields.blank", "fields entries must be non-empty");
+					break;
+				}
+				if (seen.has(field)) {
+					push("overlay.mod.reorderFields.fields.duplicate", `field "${field}" was listed multiple times`);
+					break;
+				}
+				seen.add(field);
+			}
+			break;
+		}
+		case "setDefault":
+			if (modification.value === void 0) push("overlay.mod.setDefault.value", "value is required", ["value"]);
+			break;
+		case "addHelpText":
+			if (!modification.text?.trim()) push("overlay.mod.addHelpText.text", "text is required", ["text"]);
+			break;
+		case "makeRequired":
+		case "hideField": break;
+		default: {
+			const exhaustive = modification;
+			throw new Error(`Unsupported overlay modification ${exhaustive?.type ?? "unknown"}`);
+		}
+	}
+}
+function isFieldModification(mod) {
+	return "field" in mod;
+}
+
+//#endregion
+export { defaultOverlayValidator, validateOverlaySpec };

package/dist/libs/personalization/dist/analyzer.js

@@ -1 +1,54 @@
-var e=class{constructor(e,t={}){this.store=e,this.options=t}async analyze(e){let n={tenantId:e.tenantId,userId:e.userId,role:e.role};return e.windowMs&&(n.since=Date.now()-e.windowMs),t(await this.store.summarize(n),this.options)}};function t(e,t){let r=t.fieldInactivityThreshold??3,i=t.minSamples??10,a=[],o=[];for(let[t,n]of Object.entries(e.fieldCounts))n<=r&&a.push(t),n>=r*4&&o.push(t);let s=Object.entries(e.workflowStepCounts).flatMap(([e,t])=>{let n=Object.values(t).reduce((e,t)=>e+t,0);return!n||n<i?[]:Object.entries(t).filter(([,e])=>e/n<.4).map(([t,r])=>({workflow:e,step:t,dropRate:1-r/n}))}),c=n(e);return{unusedFields:a,suggestedHiddenFields:a.slice(0,5),frequentlyUsedFields:o.slice(0,10),workflowBottlenecks:s,layoutPreference:c}}function n(e){let t=Object.keys(e.fieldCounts).length;if(t)return t>=15?`table`:t>=8?`grid`:`form`}export{e};
+//#region ../../libs/personalization/dist/analyzer.js
+const DEFAULT_THRESHOLD = 3;
+var BehaviorAnalyzer = class {
+	constructor(store, options = {}) {
+		this.store = store;
+		this.options = options;
+	}
+	async analyze(params) {
+		const query = {
+			tenantId: params.tenantId,
+			userId: params.userId,
+			role: params.role
+		};
+		if (params.windowMs) query.since = Date.now() - params.windowMs;
+		return buildInsights(await this.store.summarize(query), this.options);
+	}
+};
+function buildInsights(summary, options) {
+	const threshold = options.fieldInactivityThreshold ?? DEFAULT_THRESHOLD;
+	const minSamples = options.minSamples ?? 10;
+	const ignoredFields = [];
+	const frequentlyUsedFields = [];
+	for (const [field, count] of Object.entries(summary.fieldCounts)) {
+		if (count <= threshold) ignoredFields.push(field);
+		if (count >= threshold * 4) frequentlyUsedFields.push(field);
+	}
+	const workflowBottlenecks = Object.entries(summary.workflowStepCounts).flatMap(([workflow, steps]) => {
+		const total = Object.values(steps).reduce((acc, value) => acc + value, 0);
+		if (!total || total < minSamples) return [];
+		return Object.entries(steps).filter(([, count]) => count / total < .4).map(([step, count]) => ({
+			workflow,
+			step,
+			dropRate: 1 - count / total
+		}));
+	});
+	const layoutPreference = detectLayout(summary);
+	return {
+		unusedFields: ignoredFields,
+		suggestedHiddenFields: ignoredFields.slice(0, 5),
+		frequentlyUsedFields: frequentlyUsedFields.slice(0, 10),
+		workflowBottlenecks,
+		layoutPreference
+	};
+}
+function detectLayout(summary) {
+	const fieldCount = Object.keys(summary.fieldCounts).length;
+	if (!fieldCount) return;
+	if (fieldCount >= 15) return "table";
+	if (fieldCount >= 8) return "grid";
+	return "form";
+}
+
+//#endregion
+export { BehaviorAnalyzer };

package/dist/libs/personalization/dist/store.js

@@ -1 +1,58 @@
-var e=class{events=[];async record(e){this.events.push(e)}async bulkRecord(e){this.events.push(...e)}async query(e){return t(this.events,e)}async summarize(e){let t=await this.query(e),n={fieldCounts:{},featureCounts:{},workflowStepCounts:{},totalEvents:t.length};return t.forEach(e=>{switch(e.type){case`field_access`:n.fieldCounts[e.field]=(n.fieldCounts[e.field]??0)+1;break;case`feature_usage`:n.featureCounts[e.feature]=(n.featureCounts[e.feature]??0)+1;break;case`workflow_step`:{let t=n.workflowStepCounts[e.workflow]??={};t[e.step]=(t[e.step]??0)+1;break}default:break}}),n}async clear(){this.events=[]}};function t(e,t){return e.filter(e=>!(t.tenantId&&e.tenantId!==t.tenantId||t.userId&&e.userId!==t.userId||t.role&&e.role!==t.role||t.since&&e.timestamp<t.since||t.until&&e.timestamp>t.until||t.operation&&e.type===`field_access`&&e.operation!==t.operation||t.feature&&e.type===`feature_usage`&&e.feature!==t.feature||t.workflow&&e.type===`workflow_step`&&e.workflow!==t.workflow))}export{e};
+//#region ../../libs/personalization/dist/store.js
+var InMemoryBehaviorStore = class {
+	events = [];
+	async record(event) {
+		this.events.push(event);
+	}
+	async bulkRecord(events) {
+		this.events.push(...events);
+	}
+	async query(query) {
+		return filterEvents(this.events, query);
+	}
+	async summarize(query) {
+		const events = await this.query(query);
+		const summary = {
+			fieldCounts: {},
+			featureCounts: {},
+			workflowStepCounts: {},
+			totalEvents: events.length
+		};
+		events.forEach((event) => {
+			switch (event.type) {
+				case "field_access":
+					summary.fieldCounts[event.field] = (summary.fieldCounts[event.field] ?? 0) + 1;
+					break;
+				case "feature_usage":
+					summary.featureCounts[event.feature] = (summary.featureCounts[event.feature] ?? 0) + 1;
+					break;
+				case "workflow_step": {
+					const workflow = summary.workflowStepCounts[event.workflow] ??= {};
+					workflow[event.step] = (workflow[event.step] ?? 0) + 1;
+					break;
+				}
+				default: break;
+			}
+		});
+		return summary;
+	}
+	async clear() {
+		this.events = [];
+	}
+};
+function filterEvents(events, query) {
+	return events.filter((event) => {
+		if (query.tenantId && event.tenantId !== query.tenantId) return false;
+		if (query.userId && event.userId !== query.userId) return false;
+		if (query.role && event.role !== query.role) return false;
+		if (query.since && event.timestamp < query.since) return false;
+		if (query.until && event.timestamp > query.until) return false;
+		if (query.operation && event.type === "field_access" && event.operation !== query.operation) return false;
+		if (query.feature && event.type === "feature_usage" && event.feature !== query.feature) return false;
+		if (query.workflow && event.type === "workflow_step" && event.workflow !== query.workflow) return false;
+		return true;
+	});
+}
+
+//#endregion
+export { InMemoryBehaviorStore };

package/dist/libs/personalization/dist/tracker.js

@@ -1 +1,92 @@
-import{metrics as e,trace as t}from"@opentelemetry/api";var n=class{store;context;tracer=t.getTracer(`lssm.personalization`,`1.0.0`);counter=e.getMeter(`lssm.personalization`,`1.0.0`).createCounter(`lssm.personalization.events`,{description:`Behavior events tracked for personalization`});buffer=[];bufferSize;flushTimer;constructor(e){this.store=e.store,this.context=e.context,this.bufferSize=e.bufferSize??25,e.autoFlushIntervalMs&&(this.flushTimer=setInterval(()=>{this.flush()},e.autoFlushIntervalMs))}trackFieldAccess(e){let t={type:`field_access`,operation:e.operation,field:e.field,timestamp:Date.now(),...this.context,metadata:{...this.context.metadata,...e.metadata}};this.enqueue(t)}trackFeatureUsage(e){let t={type:`feature_usage`,feature:e.feature,action:e.action,timestamp:Date.now(),...this.context,metadata:{...this.context.metadata,...e.metadata}};this.enqueue(t)}trackWorkflowStep(e){let t={type:`workflow_step`,workflow:e.workflow,step:e.step,status:e.status,timestamp:Date.now(),...this.context,metadata:{...this.context.metadata,...e.metadata}};this.enqueue(t)}async flush(){if(!this.buffer.length)return;let e=this.buffer;this.buffer=[],await this.store.bulkRecord(e)}async dispose(){this.flushTimer&&clearInterval(this.flushTimer),await this.flush()}enqueue(e){this.buffer.push(e),this.counter.add(1,{tenantId:this.context.tenantId,type:e.type}),this.tracer.startActiveSpan(`personalization.${e.type}`,t=>{t.setAttribute(`tenant.id`,this.context.tenantId),this.context.userId&&t.setAttribute(`user.id`,this.context.userId),t.setAttribute(`personalization.event_type`,e.type),t.end()}),this.buffer.length>=this.bufferSize&&this.flush()}};const r=e=>new n(e);export{r};
+import { metrics, trace } from "@opentelemetry/api";
+
+//#region ../../libs/personalization/dist/tracker.js
+const DEFAULT_BUFFER_SIZE = 25;
+var BehaviorTracker = class {
+	store;
+	context;
+	tracer = trace.getTracer("lssm.personalization", "1.0.0");
+	counter = metrics.getMeter("lssm.personalization", "1.0.0").createCounter("lssm.personalization.events", { description: "Behavior events tracked for personalization" });
+	buffer = [];
+	bufferSize;
+	flushTimer;
+	constructor(options) {
+		this.store = options.store;
+		this.context = options.context;
+		this.bufferSize = options.bufferSize ?? DEFAULT_BUFFER_SIZE;
+		if (options.autoFlushIntervalMs) this.flushTimer = setInterval(() => {
+			this.flush();
+		}, options.autoFlushIntervalMs);
+	}
+	trackFieldAccess(input) {
+		const event = {
+			type: "field_access",
+			operation: input.operation,
+			field: input.field,
+			timestamp: Date.now(),
+			...this.context,
+			metadata: {
+				...this.context.metadata,
+				...input.metadata
+			}
+		};
+		this.enqueue(event);
+	}
+	trackFeatureUsage(input) {
+		const event = {
+			type: "feature_usage",
+			feature: input.feature,
+			action: input.action,
+			timestamp: Date.now(),
+			...this.context,
+			metadata: {
+				...this.context.metadata,
+				...input.metadata
+			}
+		};
+		this.enqueue(event);
+	}
+	trackWorkflowStep(input) {
+		const event = {
+			type: "workflow_step",
+			workflow: input.workflow,
+			step: input.step,
+			status: input.status,
+			timestamp: Date.now(),
+			...this.context,
+			metadata: {
+				...this.context.metadata,
+				...input.metadata
+			}
+		};
+		this.enqueue(event);
+	}
+	async flush() {
+		if (!this.buffer.length) return;
+		const events = this.buffer;
+		this.buffer = [];
+		await this.store.bulkRecord(events);
+	}
+	async dispose() {
+		if (this.flushTimer) clearInterval(this.flushTimer);
+		await this.flush();
+	}
+	enqueue(event) {
+		this.buffer.push(event);
+		this.counter.add(1, {
+			tenantId: this.context.tenantId,
+			type: event.type
+		});
+		this.tracer.startActiveSpan(`personalization.${event.type}`, (span) => {
+			span.setAttribute("tenant.id", this.context.tenantId);
+			if (this.context.userId) span.setAttribute("user.id", this.context.userId);
+			span.setAttribute("personalization.event_type", event.type);
+			span.end();
+		});
+		if (this.buffer.length >= this.bufferSize) this.flush();
+	}
+};
+const createBehaviorTracker = (options) => new BehaviorTracker(options);
+
+//#endregion
+export { createBehaviorTracker };

package/dist/libs/workflow-composer/dist/composer.js

@@ -1 +1,28 @@
-import{t as e}from"./injector.js";var t=class{extensions=[];register(e){return this.extensions.push(e),this}registerMany(e){return e.forEach(e=>this.register(e)),this}compose(t){return this.extensions.filter(e=>n(t,e)).sort((e,t)=>(e.priority??0)-(t.priority??0)).reduce((t,n)=>e(t,n),t.base)}};function n(e,t){return!(t.workflow!==e.base.meta.name||t.baseVersion&&t.baseVersion!==e.base.meta.version||t.tenantId&&t.tenantId!==e.tenantId||t.role&&t.role!==e.role||t.device&&t.device!==e.device)}export{t};
+import { applyWorkflowExtension } from "./injector.js";
+
+//#region ../../libs/workflow-composer/dist/composer.js
+var WorkflowComposer = class {
+	extensions = [];
+	register(extension) {
+		this.extensions.push(extension);
+		return this;
+	}
+	registerMany(extensions) {
+		extensions.forEach((extension) => this.register(extension));
+		return this;
+	}
+	compose(params) {
+		return this.extensions.filter((extension) => matches(params, extension)).sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0)).reduce((acc, extension) => applyWorkflowExtension(acc, extension), params.base);
+	}
+};
+function matches(params, extension) {
+	if (extension.workflow !== params.base.meta.name) return false;
+	if (extension.baseVersion && extension.baseVersion !== params.base.meta.version) return false;
+	if (extension.tenantId && extension.tenantId !== params.tenantId) return false;
+	if (extension.role && extension.role !== params.role) return false;
+	if (extension.device && extension.device !== params.device) return false;
+	return true;
+}
+
+//#endregion
+export { WorkflowComposer };

package/dist/libs/workflow-composer/dist/injector.js

@@ -1 +1,72 @@
-import{e}from"./validator.js";function t(t,r){e(r,t);let s=o(t),c=[...s.definition.steps],l=[...s.definition.transitions],u=new Set(r.hiddenSteps??[]);return u.forEach(e=>{let t=c.findIndex(t=>t.id===e);t!==-1&&c.splice(t,1)}),u.size&&(l=l.filter(e=>!u.has(e.from)&&!u.has(e.to))),r.customSteps?.forEach(e=>{n(c,e),i(l,e)}),s.definition.steps=c,s.definition.transitions=a(l),s.meta={...s.meta,version:s.meta.version},s}function n(e,t){let n=r(e,t);if(n===-1)throw Error(`Unable to place injected step "${t.inject.id}"`);e.splice(n,0,{...t.inject})}function r(e,t){if(t.after){let n=e.findIndex(e=>e.id===t.after);return n===-1?-1:n+1}if(t.before){let n=e.findIndex(e=>e.id===t.before);return n===-1?-1:n}return e.length}function i(e,t){t.inject.id&&(t.transitionFrom&&e.push({from:t.transitionFrom,to:t.inject.id,condition:t.when}),t.transitionTo&&e.push({from:t.inject.id,to:t.transitionTo,condition:t.when}))}function a(e){let t=new Set,n=[];return e.forEach(e=>{let r=`${e.from}->${e.to}:${e.condition??``}`;t.has(r)||(t.add(r),n.push(e))}),n}function o(e){return JSON.parse(JSON.stringify(e))}export{t};
+import { validateExtension } from "./validator.js";
+
+//#region ../../libs/workflow-composer/dist/injector.js
+function applyWorkflowExtension(base, extension) {
+	validateExtension(extension, base);
+	const spec = cloneWorkflowSpec(base);
+	const steps = [...spec.definition.steps];
+	let transitions = [...spec.definition.transitions];
+	const hiddenSet = new Set(extension.hiddenSteps ?? []);
+	hiddenSet.forEach((stepId) => {
+		const idx = steps.findIndex((step) => step.id === stepId);
+		if (idx !== -1) steps.splice(idx, 1);
+	});
+	if (hiddenSet.size) transitions = transitions.filter((transition) => !hiddenSet.has(transition.from) && !hiddenSet.has(transition.to));
+	extension.customSteps?.forEach((injection) => {
+		insertStep(steps, injection);
+		wireTransitions(transitions, injection);
+	});
+	spec.definition.steps = steps;
+	spec.definition.transitions = dedupeTransitions(transitions);
+	spec.meta = {
+		...spec.meta,
+		version: spec.meta.version
+	};
+	return spec;
+}
+function insertStep(steps, injection) {
+	const anchorIndex = resolveAnchorIndex(steps, injection);
+	if (anchorIndex === -1) throw new Error(`Unable to place injected step "${injection.inject.id}"`);
+	steps.splice(anchorIndex, 0, { ...injection.inject });
+}
+function resolveAnchorIndex(steps, injection) {
+	if (injection.after) {
+		const idx = steps.findIndex((step) => step.id === injection.after);
+		return idx === -1 ? -1 : idx + 1;
+	}
+	if (injection.before) {
+		const idx = steps.findIndex((step) => step.id === injection.before);
+		return idx === -1 ? -1 : idx;
+	}
+	return steps.length;
+}
+function wireTransitions(transitions, injection) {
+	if (!injection.inject.id) return;
+	if (injection.transitionFrom) transitions.push({
+		from: injection.transitionFrom,
+		to: injection.inject.id,
+		condition: injection.when
+	});
+	if (injection.transitionTo) transitions.push({
+		from: injection.inject.id,
+		to: injection.transitionTo,
+		condition: injection.when
+	});
+}
+function dedupeTransitions(transitions) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	transitions.forEach((transition) => {
+		const key = `${transition.from}->${transition.to}:${transition.condition ?? ""}`;
+		if (seen.has(key)) return;
+		seen.add(key);
+		result.push(transition);
+	});
+	return result;
+}
+function cloneWorkflowSpec(spec) {
+	return JSON.parse(JSON.stringify(spec));
+}
+
+//#endregion
+export { applyWorkflowExtension };

package/dist/libs/workflow-composer/dist/validator.js

@@ -1 +1,36 @@
-function e(e,t){let n=[],r=new Set(t.definition.steps.map(e=>e.id));if(e.customSteps?.forEach((e,t)=>{e.inject.id||n.push({code:`workflow.extension.step.id`,message:`customSteps[${t}] is missing an id`}),!e.after&&!e.before&&n.push({code:`workflow.extension.step.anchor`,message:`customSteps[${t}] must set after or before`}),e.after&&!r.has(e.after)&&n.push({code:`workflow.extension.step.after`,message:`customSteps[${t}] references unknown step "${e.after}"`}),e.before&&!r.has(e.before)&&n.push({code:`workflow.extension.step.before`,message:`customSteps[${t}] references unknown step "${e.before}"`})}),e.hiddenSteps?.forEach(e=>{r.has(e)||n.push({code:`workflow.extension.hidden-step`,message:`hidden step "${e}" does not exist`})}),n.length){let t=n.map(e=>`${e.code}: ${e.message}`).join(`; `);throw Error(`Invalid workflow extension for ${e.workflow}: ${t}`)}}export{e};
+//#region ../../libs/workflow-composer/dist/validator.js
+function validateExtension(extension, base) {
+	const issues = [];
+	const stepIds = new Set(base.definition.steps.map((step) => step.id));
+	extension.customSteps?.forEach((injection, idx) => {
+		if (!injection.inject.id) issues.push({
+			code: "workflow.extension.step.id",
+			message: `customSteps[${idx}] is missing an id`
+		});
+		if (!injection.after && !injection.before) issues.push({
+			code: "workflow.extension.step.anchor",
+			message: `customSteps[${idx}] must set after or before`
+		});
+		if (injection.after && !stepIds.has(injection.after)) issues.push({
+			code: "workflow.extension.step.after",
+			message: `customSteps[${idx}] references unknown step "${injection.after}"`
+		});
+		if (injection.before && !stepIds.has(injection.before)) issues.push({
+			code: "workflow.extension.step.before",
+			message: `customSteps[${idx}] references unknown step "${injection.before}"`
+		});
+	});
+	extension.hiddenSteps?.forEach((stepId) => {
+		if (!stepIds.has(stepId)) issues.push({
+			code: "workflow.extension.hidden-step",
+			message: `hidden step "${stepId}" does not exist`
+		});
+	});
+	if (issues.length) {
+		const reason = issues.map((issue) => `${issue.code}: ${issue.message}`).join("; ");
+		throw new Error(`Invalid workflow extension for ${extension.workflow}: ${reason}`);
+	}
+}
+
+//#endregion
+export { validateExtension };

package/dist/overlay-customization.js

@@ -1 +1,53 @@
-import{e}from"./libs/logger/dist/types.js";import{o as t}from"./libs/logger/dist/logger.node.js";import"./libs/logger/dist/index.js";import{t as n}from"./libs/overlay-engine/dist/spec.js";import{o as r}from"./libs/overlay-engine/dist/signer.js";import{r as i}from"./libs/overlay-engine/dist/registry.js";import{t as a}from"./libs/overlay-engine/dist/runtime.js";import"./libs/overlay-engine/dist/index.js";const o=new t({level:process.env.NODE_ENV===`production`?e.INFO:e.DEBUG,environment:process.env.NODE_ENV||`development`,enableColors:process.env.NODE_ENV!==`production`});async function s(){let e=new i({allowUnsigned:!0}),t=new a({registry:e}),s=await r(n({overlayId:`demo-overlay`,version:`1.0.0`,appliesTo:{capability:`billing.createOrder`,tenantId:`demo`},modifications:[{type:`hideField`,field:`internalNotes`},{type:`renameLabel`,field:`customerReference`,newLabel:`PO Number`}]}),process.env.PRIVATE_KEY_PEM??``);e.register(s);let c=t.apply({target:{fields:[{key:`customerReference`,label:`Customer Reference`,visible:!0},{key:`internalNotes`,label:`Internal Notes`,visible:!0}]},capability:`billing.createOrder`,tenantId:`demo`});o.info(`Overlay applied`,{fields:c.target.fields})}export{s as runOverlayCustomizationExample};
+import { LogLevel } from "./libs/logger/dist/types.js";
+import { Logger } from "./libs/logger/dist/logger.node.js";
+import "./libs/logger/dist/index.js";
+import { defineOverlay } from "./libs/overlay-engine/dist/spec.js";
+import { signOverlay } from "./libs/overlay-engine/dist/signer.js";
+import { OverlayRegistry } from "./libs/overlay-engine/dist/registry.js";
+import { OverlayEngine } from "./libs/overlay-engine/dist/runtime.js";
+import "./libs/overlay-engine/dist/index.js";
+
+//#region src/overlay-customization.ts
+const logger = new Logger({
+	level: process.env.NODE_ENV === "production" ? LogLevel.INFO : LogLevel.DEBUG,
+	environment: process.env.NODE_ENV || "development",
+	enableColors: process.env.NODE_ENV !== "production"
+});
+async function runOverlayCustomizationExample() {
+	const registry = new OverlayRegistry({ allowUnsigned: true });
+	const engine = new OverlayEngine({ registry });
+	const signed = await signOverlay(defineOverlay({
+		overlayId: "demo-overlay",
+		version: "1.0.0",
+		appliesTo: {
+			capability: "billing.createOrder",
+			tenantId: "demo"
+		},
+		modifications: [{
+			type: "hideField",
+			field: "internalNotes"
+		}, {
+			type: "renameLabel",
+			field: "customerReference",
+			newLabel: "PO Number"
+		}]
+	}), process.env.PRIVATE_KEY_PEM ?? "");
+	registry.register(signed);
+	const result = engine.apply({
+		target: { fields: [{
+			key: "customerReference",
+			label: "Customer Reference",
+			visible: true
+		}, {
+			key: "internalNotes",
+			label: "Internal Notes",
+			visible: true
+		}] },
+		capability: "billing.createOrder",
+		tenantId: "demo"
+	});
+	logger.info("Overlay applied", { fields: result.target.fields });
+}
+
+//#endregion
+export { runOverlayCustomizationExample };