@lssm/example.personalization 0.0.0-canary-20251217080011 → 1.41.0

package/dist/libs/logger/dist/timer.js

@@ -1,126 +0,0 @@
-//#region ../../libs/logger/dist/timer.mjs
-var Timer = class {
-	id;
-	startTime;
-	laps = [];
-	stopped = false;
-	stopTime;
-	constructor(id) {
-		this.id = id || crypto.randomUUID();
-		this.startTime = performance.now();
-	}
-	/**
-	* Stop the timer and return elapsed time in milliseconds
-	*/
-	stop() {
-		if (this.stopped) return this.getElapsed();
-		this.stopTime = performance.now();
-		this.stopped = true;
-		const elapsed = this.stopTime - this.startTime;
-		this.laps.push({
-			label: "stop",
-			time: this.stopTime,
-			elapsed
-		});
-		return elapsed;
-	}
-	/**
-	* Record a lap time and return elapsed time since start
-	*/
-	lap(label) {
-		if (this.stopped) return this.getElapsed();
-		const now = performance.now();
-		const elapsed = now - this.startTime;
-		this.laps.push({
-			label: label || `lap-${this.laps.length + 1}`,
-			time: now,
-			elapsed
-		});
-		return elapsed;
-	}
-	/**
-	* Get elapsed time without stopping the timer
-	*/
-	getElapsed() {
-		if (this.stopped && this.stopTime) return this.stopTime - this.startTime;
-		return performance.now() - this.startTime;
-	}
-	/**
-	* Get all recorded laps
-	*/
-	getLaps() {
-		return [...this.laps];
-	}
-	/**
-	* Get timer summary with total time and laps
-	*/
-	getSummary() {
-		return {
-			id: this.id,
-			totalTime: this.getElapsed(),
-			isRunning: !this.stopped,
-			laps: this.getLaps()
-		};
-	}
-	/**
-	* Reset the timer (starts a new timing session)
-	*/
-	reset() {
-		this.startTime = performance.now();
-		this.laps = [];
-		this.stopped = false;
-		this.stopTime = void 0;
-	}
-};
-/**
-* Utility class for managing multiple timers
-*/
-var TimerManager = class {
-	timers = /* @__PURE__ */ new Map();
-	/**
-	* Start a new timer
-	*/
-	start(id) {
-		const timer = new Timer(id);
-		this.timers.set(timer.id, timer);
-		return timer;
-	}
-	/**
-	* Get an existing timer
-	*/
-	get(id) {
-		return this.timers.get(id);
-	}
-	/**
-	* Stop and remove a timer
-	*/
-	stop(id) {
-		const timer = this.timers.get(id);
-		if (timer) {
-			const elapsed = timer.stop();
-			this.timers.delete(id);
-			return elapsed;
-		}
-	}
-	/**
-	* Get all active timers
-	*/
-	getActive() {
-		return Array.from(this.timers.values()).filter((timer) => !timer.getSummary().isRunning === false);
-	}
-	/**
-	* Clear all timers
-	*/
-	clear() {
-		this.timers.clear();
-	}
-	/**
-	* Get summary of all timers
-	*/
-	getSummary() {
-		return Array.from(this.timers.values()).map((timer) => timer.getSummary());
-	}
-};
-
-//#endregion
-export { Timer, TimerManager };

package/dist/libs/logger/dist/tracer.node.js

@@ -1,115 +0,0 @@
-import { LogContext } from "./context.node.js";
-import { Timer } from "./timer.js";
-
-//#region ../../libs/logger/dist/tracer.node.mjs
-var Tracer = class {
-	context;
-	activeSpans = /* @__PURE__ */ new Map();
-	constructor() {
-		this.context = LogContext.getInstance();
-	}
-	/**
-	* Start a new trace span
-	*/
-	startSpan(options) {
-		const parentTrace = this.context.getCurrentTrace();
-		const span = {
-			traceId: parentTrace?.traceId || this.generateTraceId(),
-			parentId: parentTrace?.spanId,
-			spanId: this.generateSpanId(),
-			operationType: options.operationType,
-			operationName: options.operationName,
-			startTime: performance.now(),
-			metadata: { ...options.metadata },
-			tags: [...options.tags || []]
-		};
-		this.activeSpans.set(span.spanId, span);
-		this.context.setTrace(span);
-		return span;
-	}
-	/**
-	* Finish a trace span
-	*/
-	finishSpan(spanId) {
-		const span = this.activeSpans.get(spanId);
-		if (!span) return;
-		const duration = performance.now() - span.startTime;
-		this.activeSpans.delete(spanId);
-		if (this.context.getCurrentTrace()?.spanId === spanId && span.parentId) {
-			const parentSpan = this.findSpanById(span.parentId);
-			if (parentSpan) this.context.setTrace(parentSpan);
-		}
-		return duration;
-	}
-	/**
-	* Execute a function within a trace span
-	*/
-	async trace(options, fn) {
-		const span = this.startSpan(options);
-		const timer = options.autoTiming !== false ? new Timer(`trace-${span.spanId}`) : void 0;
-		try {
-			const result = await fn();
-			const duration = this.finishSpan(span.spanId);
-			if (timer) timer.stop();
-			if (duration !== void 0) span.metadata.duration = duration;
-			return result;
-		} catch (error) {
-			span.metadata.error = {
-				name: error.name || "Unknown",
-				message: error.message || "Unknown error",
-				stack: error.stack
-			};
-			const duration = this.finishSpan(span.spanId);
-			span.metadata.duration = duration;
-			if (timer) timer.stop();
-			throw error;
-		}
-	}
-	/**
-	* Add metadata to current span
-	*/
-	addMetadata(key, value) {
-		const currentTrace = this.context.getCurrentTrace();
-		if (currentTrace) currentTrace.metadata[key] = value;
-	}
-	/**
-	* Add tags to current span
-	*/
-	addTags(...tags) {
-		const currentTrace = this.context.getCurrentTrace();
-		if (currentTrace) currentTrace.tags.push(...tags);
-	}
-	/**
-	* Get current trace context
-	*/
-	getCurrentTrace() {
-		return this.context.getCurrentTrace();
-	}
-	/**
-	* Get all active spans
-	*/
-	getActiveSpans() {
-		return Array.from(this.activeSpans.values());
-	}
-	/**
-	* Find a span by ID
-	*/
-	findSpanById(spanId) {
-		return this.activeSpans.get(spanId);
-	}
-	/**
-	* Generate a unique trace ID
-	*/
-	generateTraceId() {
-		return crypto.randomUUID().replace(/-/g, "");
-	}
-	/**
-	* Generate a unique span ID
-	*/
-	generateSpanId() {
-		return crypto.randomUUID().replace(/-/g, "").substring(0, 16);
-	}
-};
-
-//#endregion
-export { Tracer };

package/dist/libs/logger/dist/types.js

@@ -1,13 +0,0 @@
-//#region ../../libs/logger/dist/types.mjs
-let LogLevel = /* @__PURE__ */ function(LogLevel$1) {
-	LogLevel$1[LogLevel$1["TRACE"] = 0] = "TRACE";
-	LogLevel$1[LogLevel$1["DEBUG"] = 1] = "DEBUG";
-	LogLevel$1[LogLevel$1["INFO"] = 2] = "INFO";
-	LogLevel$1[LogLevel$1["WARN"] = 3] = "WARN";
-	LogLevel$1[LogLevel$1["ERROR"] = 4] = "ERROR";
-	LogLevel$1[LogLevel$1["FATAL"] = 5] = "FATAL";
-	return LogLevel$1;
-}({});
-
-//#endregion
-export { LogLevel };

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

@@ -1,6 +0,0 @@
-import { defineOverlay } from "./spec.js";
-import { canonicalizeOverlay, signOverlay } from "./signer.js";
-import { defaultOverlayValidator, validateOverlaySpec } from "./validator.js";
-import { OverlayRegistry } from "./registry.js";
-import { applyOverlayModifications } from "./merger.js";
-import { OverlayEngine } from "./runtime.js";

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

@@ -1,106 +0,0 @@
-//#region ../../libs/overlay-engine/dist/merger.js
-function applyOverlayModifications(target, overlays, options = {}) {
-	if (!overlays.length) return target;
-	const states = target.fields.map((field) => ({
-		key: field.key,
-		field: { ...field },
-		hidden: field.visible === false
-	}));
-	const fieldMap = new Map(states.map((state) => [state.key, state]));
-	let orderSequence = target.fields.map((field) => field.key);
-	const handleMissing = (field, overlayId) => {
-		if (options.strict) throw new Error(`Overlay "${overlayId}" referenced unknown field "${field}".`);
-	};
-	overlays.forEach((overlay) => {
-		overlay.modifications.forEach((modification) => {
-			switch (modification.type) {
-				case "hideField": {
-					const state = fieldMap.get(modification.field);
-					if (!state) return handleMissing(modification.field, overlay.overlayId);
-					state.hidden = true;
-					state.field.visible = false;
-					break;
-				}
-				case "renameLabel": {
-					const state = fieldMap.get(modification.field);
-					if (!state) return handleMissing(modification.field, overlay.overlayId);
-					state.field.label = modification.newLabel;
-					break;
-				}
-				case "setDefault": {
-					const state = fieldMap.get(modification.field);
-					if (!state) return handleMissing(modification.field, overlay.overlayId);
-					state.field.defaultValue = modification.value;
-					break;
-				}
-				case "addHelpText": {
-					const state = fieldMap.get(modification.field);
-					if (!state) return handleMissing(modification.field, overlay.overlayId);
-					state.field.helpText = modification.text;
-					break;
-				}
-				case "makeRequired": {
-					const state = fieldMap.get(modification.field);
-					if (!state) return handleMissing(modification.field, overlay.overlayId);
-					state.field.required = modification.required ?? true;
-					break;
-				}
-				case "reorderFields": {
-					const { filtered, missing } = normalizeOrderList(modification.fields, fieldMap);
-					if (missing.length && options.strict) missing.forEach((field) => handleMissing(field, overlay.overlayId));
-					orderSequence = applyReorder(orderSequence, filtered);
-					break;
-				}
-				default: break;
-			}
-		});
-	});
-	const visibleFields = [];
-	const seen = /* @__PURE__ */ new Set();
-	orderSequence.forEach((key) => {
-		const state = fieldMap.get(key);
-		if (!state || state.hidden) return;
-		seen.add(key);
-		visibleFields.push(state.field);
-	});
-	states.forEach((state) => {
-		if (state.hidden || seen.has(state.key)) return;
-		visibleFields.push(state.field);
-	});
-	visibleFields.forEach((field, index) => {
-		field.order = index;
-		field.visible = true;
-	});
-	return {
-		...target,
-		fields: visibleFields
-	};
-}
-function normalizeOrderList(fields, fieldMap) {
-	const filtered = [];
-	const missing = [];
-	const seen = /* @__PURE__ */ new Set();
-	fields.forEach((field) => {
-		if (!field?.trim()) return;
-		if (!fieldMap.has(field)) {
-			missing.push(field);
-			return;
-		}
-		if (seen.has(field)) return;
-		seen.add(field);
-		filtered.push(field);
-	});
-	return {
-		filtered,
-		missing
-	};
-}
-function applyReorder(sequence, orderedFields) {
-	if (!orderedFields.length) return sequence;
-	const orderedSet = new Set(orderedFields);
-	const remainder = sequence.filter((key) => !orderedSet.has(key));
-	return [...orderedFields, ...remainder];
-}
-
-//#endregion
-export { applyOverlayModifications };

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

@@ -1,106 +0,0 @@
-import { defaultOverlayValidator } from "./validator.js";
-
-//#region ../../libs/overlay-engine/dist/registry.js
-const TARGET_KEYS = [
-	"capability",
-	"workflow",
-	"dataView",
-	"presentation",
-	"operation"
-];
-const SCOPE_WEIGHTS = {
-	tenantId: 8,
-	role: 4,
-	userId: 16,
-	device: 2,
-	tags: 1
-};
-var OverlayRegistry = class {
-	overlays = /* @__PURE__ */ new Map();
-	constructor(options = {}) {
-		this.options = options;
-	}
-	register(overlay, options) {
-		if (!options?.skipValidation) {
-			const result = (this.options.validator ?? defaultOverlayValidator)(overlay);
-			if (!result.valid) {
-				const reason = result.issues.map((issue) => `${issue.code}: ${issue.message}`).join("; ");
-				throw new Error(`Overlay "${overlay.overlayId}" failed validation: ${reason}`);
-			}
-		}
-		const normalized = this.ensureSigned(overlay);
-		const key = this.getKey(normalized.overlayId, normalized.version);
-		const stored = {
-			overlay: normalized,
-			specificity: computeSpecificity(normalized.appliesTo),
-			registeredAt: Date.now()
-		};
-		this.overlays.set(key, stored);
-		return normalized;
-	}
-	unregister(overlayId, version) {
-		if (version) {
-			this.overlays.delete(this.getKey(overlayId, version));
-			return;
-		}
-		for (const key of Array.from(this.overlays.keys())) if (key.startsWith(`${overlayId}@`)) this.overlays.delete(key);
-	}
-	list() {
-		return Array.from(this.overlays.values()).map((entry) => entry.overlay);
-	}
-	get(overlayId, version) {
-		return this.overlays.get(this.getKey(overlayId, version))?.overlay;
-	}
-	forContext(query) {
-		return Array.from(this.overlays.values()).filter((entry) => matches(entry.overlay.appliesTo, query)).sort((a, b) => {
-			if (a.specificity !== b.specificity) return a.specificity - b.specificity;
-			return a.registeredAt - b.registeredAt;
-		}).map((entry) => entry.overlay);
-	}
-	clear() {
-		this.overlays.clear();
-	}
-	size() {
-		return this.overlays.size;
-	}
-	ensureSigned(input) {
-		if (isSignedOverlay(input)) {
-			if (!input.signature?.signature && !this.options.allowUnsigned) throw new Error(`Overlay "${input.overlayId}" is missing a signature.`);
-			return input;
-		}
-		if (!this.options.allowUnsigned) throw new Error(`Overlay "${input.overlayId}" must be signed before registration.`);
-		return input;
-	}
-	getKey(overlayId, version) {
-		return `${overlayId}@${version}`;
-	}
-};
-function isSignedOverlay(spec) {
-	return Boolean(spec.signature);
-}
-function computeSpecificity(appliesTo) {
-	let score = 0;
-	Object.keys(SCOPE_WEIGHTS).forEach((key) => {
-		if (key === "tags" ? Array.isArray(appliesTo.tags) && appliesTo.tags.length > 0 : Boolean(appliesTo[key])) score += SCOPE_WEIGHTS[key];
-	});
-	return score;
-}
-function matches(appliesTo, ctx) {
-	for (const key of TARGET_KEYS) {
-		const expected = appliesTo[key];
-		if (expected && expected !== ctx[key]) return false;
-	}
-	if (appliesTo.tenantId && appliesTo.tenantId !== ctx.tenantId) return false;
-	if (appliesTo.role && appliesTo.role !== ctx.role) return false;
-	if (appliesTo.userId && appliesTo.userId !== ctx.userId) return false;
-	if (appliesTo.device && appliesTo.device !== ctx.device) return false;
-	if (appliesTo.tags?.length) {
-		if (!ctx.tags?.length) return false;
-		const ctxTags = new Set(ctx.tags);
-		if (!appliesTo.tags.every((tag) => ctxTags.has(tag))) return false;
-	}
-	return true;
-}
-
-//#endregion
-export { OverlayRegistry };

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

@@ -1,53 +0,0 @@
-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,45 +0,0 @@
-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,7 +0,0 @@
-//#region ../../libs/overlay-engine/dist/spec.js
-function defineOverlay(spec) {
-	return spec;
-}
-
-//#endregion
-export { defineOverlay };

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

@@ -1,93 +0,0 @@
-//#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 };