@lssm/lib.feature-flags 0.0.0-canary-20251217083314 → 1.41.1

package/dist/docs/feature-flags.docblock.js

@@ -1,20 +1,4 @@
-import { registerDocBlocks } from "../contracts/dist/docs/registry.js";
-import "../contracts/dist/docs/index.js";
-
-//#region src/docs/feature-flags.docblock.ts
-registerDocBlocks([{
-	id: "docs.feature-flags.overview",
-	title: "Feature Flags & Experiments",
-	summary: "Reusable, spec-first feature flag and experiment module with targeting, gradual rollout, multivariate variants, and evaluation logging.",
-	kind: "reference",
-	visibility: "public",
-	route: "/docs/feature-flags/overview",
-	tags: [
-		"feature-flags",
-		"experiments",
-		"progressive-delivery"
-	],
-	body: `## What this module provides
+import{registerDocBlocks as e}from"@lssm/lib.contracts/docs";e([{id:`docs.feature-flags.overview`,title:`Feature Flags & Experiments`,summary:`Reusable, spec-first feature flag and experiment module with targeting, gradual rollout, multivariate variants, and evaluation logging.`,kind:`reference`,visibility:`public`,route:`/docs/feature-flags/overview`,tags:[`feature-flags`,`experiments`,`progressive-delivery`],body:`## What this module provides
 
 - **Entities**: FeatureFlag, FlagTargetingRule, Experiment, ExperimentAssignment, FlagEvaluation.
 - **Contracts**: create/update/delete/toggle/list/get flags; create/delete rules; evaluate flags; create/start/stop/get experiments.
@@ -70,7 +54,4 @@ if (result.enabled) {
 - Ensure experiments’ variant percentages sum to 100; default flag status to OFF.
 - Use org-scoped flags for multi-tenant isolation.
 - Log evaluations only when needed to control volume; prefer sampling for noisy paths.
-`
-}]);
-
-//#endregion
+`}]);

package/dist/docs/index.js

@@ -1 +1 @@
-import "./feature-flags.docblock.js";
+import"./feature-flags.docblock.js";

package/dist/entities/index.js

@@ -1,325 +1 @@
-import { defineEntity, defineEntityEnum, field, index } from "../schema/dist/entity/defineEntity.js";
-import "../schema/dist/index.js";
-
-//#region src/entities/index.ts
-/**
-* Feature flag status enum.
-*/
-const FlagStatusEnum = defineEntityEnum({
-	name: "FlagStatus",
-	values: [
-		"OFF",
-		"ON",
-		"GRADUAL"
-	],
-	schema: "lssm_feature_flags",
-	description: "Status of a feature flag."
-});
-/**
-* Targeting rule operator enum.
-*/
-const RuleOperatorEnum = defineEntityEnum({
-	name: "RuleOperator",
-	values: [
-		"EQ",
-		"NEQ",
-		"IN",
-		"NIN",
-		"CONTAINS",
-		"NOT_CONTAINS",
-		"GT",
-		"GTE",
-		"LT",
-		"LTE",
-		"PERCENTAGE"
-	],
-	schema: "lssm_feature_flags",
-	description: "Operator for targeting rule conditions."
-});
-/**
-* Experiment status enum.
-*/
-const ExperimentStatusEnum = defineEntityEnum({
-	name: "ExperimentStatus",
-	values: [
-		"DRAFT",
-		"RUNNING",
-		"PAUSED",
-		"COMPLETED",
-		"CANCELLED"
-	],
-	schema: "lssm_feature_flags",
-	description: "Status of an experiment."
-});
-/**
-* FeatureFlag entity - defines a feature flag.
-*/
-const FeatureFlagEntity = defineEntity({
-	name: "FeatureFlag",
-	description: "A feature flag for controlling feature availability.",
-	schema: "lssm_feature_flags",
-	map: "feature_flag",
-	fields: {
-		id: field.id({ description: "Unique flag identifier" }),
-		key: field.string({
-			isUnique: true,
-			description: "Flag key (e.g., new_dashboard)"
-		}),
-		name: field.string({ description: "Human-readable name" }),
-		description: field.string({
-			isOptional: true,
-			description: "Description of the flag"
-		}),
-		status: field.enum("FlagStatus", {
-			default: "OFF",
-			description: "Flag status"
-		}),
-		defaultValue: field.boolean({
-			default: false,
-			description: "Default value when no rules match"
-		}),
-		variants: field.json({
-			isOptional: true,
-			description: "Variant definitions for multivariate flags"
-		}),
-		orgId: field.string({
-			isOptional: true,
-			description: "Organization scope (null = global)"
-		}),
-		tags: field.json({
-			isOptional: true,
-			description: "Tags for categorization"
-		}),
-		metadata: field.json({
-			isOptional: true,
-			description: "Additional metadata"
-		}),
-		createdAt: field.createdAt(),
-		updatedAt: field.updatedAt(),
-		targetingRules: field.hasMany("FlagTargetingRule"),
-		experiments: field.hasMany("Experiment"),
-		evaluations: field.hasMany("FlagEvaluation")
-	},
-	indexes: [index.on(["orgId", "key"]), index.on(["status"])],
-	enums: [FlagStatusEnum]
-});
-/**
-* FlagTargetingRule entity - conditions for targeting.
-*/
-const FlagTargetingRuleEntity = defineEntity({
-	name: "FlagTargetingRule",
-	description: "A targeting rule for conditional flag evaluation.",
-	schema: "lssm_feature_flags",
-	map: "flag_targeting_rule",
-	fields: {
-		id: field.id({ description: "Unique rule identifier" }),
-		flagId: field.foreignKey({ description: "Parent feature flag" }),
-		name: field.string({
-			isOptional: true,
-			description: "Rule name for debugging"
-		}),
-		priority: field.int({
-			default: 0,
-			description: "Rule priority (lower = higher priority)"
-		}),
-		enabled: field.boolean({
-			default: true,
-			description: "Whether rule is active"
-		}),
-		attribute: field.string({ description: "Target attribute (userId, orgId, plan, segment, etc.)" }),
-		operator: field.enum("RuleOperator", { description: "Comparison operator" }),
-		value: field.json({ description: "Target value(s)" }),
-		rolloutPercentage: field.int({
-			isOptional: true,
-			description: "Percentage for gradual rollout (0-100)"
-		}),
-		serveValue: field.boolean({
-			isOptional: true,
-			description: "Boolean value to serve"
-		}),
-		serveVariant: field.string({
-			isOptional: true,
-			description: "Variant key to serve (for multivariate)"
-		}),
-		createdAt: field.createdAt(),
-		updatedAt: field.updatedAt(),
-		flag: field.belongsTo("FeatureFlag", ["flagId"], ["id"], { onDelete: "Cascade" })
-	},
-	indexes: [index.on(["flagId", "priority"]), index.on(["attribute"])],
-	enums: [RuleOperatorEnum]
-});
-/**
-* Experiment entity - A/B test configuration.
-*/
-const ExperimentEntity = defineEntity({
-	name: "Experiment",
-	description: "An A/B test experiment.",
-	schema: "lssm_feature_flags",
-	map: "experiment",
-	fields: {
-		id: field.id({ description: "Unique experiment identifier" }),
-		key: field.string({
-			isUnique: true,
-			description: "Experiment key"
-		}),
-		name: field.string({ description: "Human-readable name" }),
-		description: field.string({
-			isOptional: true,
-			description: "Experiment description"
-		}),
-		hypothesis: field.string({
-			isOptional: true,
-			description: "Experiment hypothesis"
-		}),
-		flagId: field.foreignKey({ description: "Associated feature flag" }),
-		status: field.enum("ExperimentStatus", {
-			default: "DRAFT",
-			description: "Experiment status"
-		}),
-		variants: field.json({ description: "Variant definitions with split ratios" }),
-		metrics: field.json({
-			isOptional: true,
-			description: "Metrics to track"
-		}),
-		audiencePercentage: field.int({
-			default: 100,
-			description: "Percentage of audience to include"
-		}),
-		audienceFilter: field.json({
-			isOptional: true,
-			description: "Audience filter criteria"
-		}),
-		scheduledStartAt: field.dateTime({
-			isOptional: true,
-			description: "Scheduled start time"
-		}),
-		scheduledEndAt: field.dateTime({
-			isOptional: true,
-			description: "Scheduled end time"
-		}),
-		startedAt: field.dateTime({
-			isOptional: true,
-			description: "Actual start time"
-		}),
-		endedAt: field.dateTime({
-			isOptional: true,
-			description: "Actual end time"
-		}),
-		winningVariant: field.string({
-			isOptional: true,
-			description: "Declared winning variant"
-		}),
-		results: field.json({
-			isOptional: true,
-			description: "Experiment results summary"
-		}),
-		orgId: field.string({
-			isOptional: true,
-			description: "Organization scope"
-		}),
-		createdAt: field.createdAt(),
-		updatedAt: field.updatedAt(),
-		flag: field.belongsTo("FeatureFlag", ["flagId"], ["id"], { onDelete: "Cascade" }),
-		assignments: field.hasMany("ExperimentAssignment")
-	},
-	indexes: [
-		index.on(["status"]),
-		index.on(["orgId", "status"]),
-		index.on(["flagId"])
-	],
-	enums: [ExperimentStatusEnum]
-});
-/**
-* ExperimentAssignment entity - tracks which variant a subject is assigned to.
-*/
-const ExperimentAssignmentEntity = defineEntity({
-	name: "ExperimentAssignment",
-	description: "Tracks experiment variant assignments.",
-	schema: "lssm_feature_flags",
-	map: "experiment_assignment",
-	fields: {
-		id: field.id({ description: "Unique assignment identifier" }),
-		experimentId: field.foreignKey({ description: "Parent experiment" }),
-		subjectType: field.string({ description: "Subject type (user, org, session)" }),
-		subjectId: field.string({ description: "Subject identifier" }),
-		variant: field.string({ description: "Assigned variant key" }),
-		bucket: field.int({ description: "Hash bucket (0-99)" }),
-		context: field.json({
-			isOptional: true,
-			description: "Context at assignment time"
-		}),
-		assignedAt: field.dateTime({ description: "Assignment timestamp" }),
-		experiment: field.belongsTo("Experiment", ["experimentId"], ["id"], { onDelete: "Cascade" })
-	},
-	indexes: [index.unique([
-		"experimentId",
-		"subjectType",
-		"subjectId"
-	], { name: "experiment_assignment_unique" }), index.on(["subjectType", "subjectId"])]
-});
-/**
-* FlagEvaluation entity - evaluation log for analytics.
-*/
-const FlagEvaluationEntity = defineEntity({
-	name: "FlagEvaluation",
-	description: "Log of flag evaluations for debugging and analytics.",
-	schema: "lssm_feature_flags",
-	map: "flag_evaluation",
-	fields: {
-		id: field.id({ description: "Unique evaluation identifier" }),
-		flagId: field.foreignKey({ description: "Evaluated flag" }),
-		flagKey: field.string({ description: "Flag key (denormalized for queries)" }),
-		subjectType: field.string({ description: "Subject type (user, org, anonymous)" }),
-		subjectId: field.string({ description: "Subject identifier" }),
-		result: field.boolean({ description: "Evaluation result" }),
-		variant: field.string({
-			isOptional: true,
-			description: "Served variant (for multivariate)"
-		}),
-		matchedRuleId: field.string({
-			isOptional: true,
-			description: "Rule that matched (if any)"
-		}),
-		reason: field.string({ description: "Evaluation reason (default, rule, experiment, etc.)" }),
-		context: field.json({
-			isOptional: true,
-			description: "Evaluation context"
-		}),
-		evaluatedAt: field.dateTime({ description: "Evaluation timestamp" }),
-		flag: field.belongsTo("FeatureFlag", ["flagId"], ["id"], { onDelete: "Cascade" })
-	},
-	indexes: [
-		index.on(["flagKey", "evaluatedAt"]),
-		index.on([
-			"subjectType",
-			"subjectId",
-			"evaluatedAt"
-		]),
-		index.on(["flagId", "evaluatedAt"])
-	]
-});
-/**
-* All feature flag entities for schema composition.
-*/
-const featureFlagEntities = [
-	FeatureFlagEntity,
-	FlagTargetingRuleEntity,
-	ExperimentEntity,
-	ExperimentAssignmentEntity,
-	FlagEvaluationEntity
-];
-/**
-* Module schema contribution for feature flags.
-*/
-const featureFlagsSchemaContribution = {
-	moduleId: "@lssm/lib.feature-flags",
-	entities: featureFlagEntities,
-	enums: [
-		FlagStatusEnum,
-		RuleOperatorEnum,
-		ExperimentStatusEnum
-	]
-};
-
-//#endregion
-export { ExperimentAssignmentEntity, ExperimentEntity, ExperimentStatusEnum, FeatureFlagEntity, FlagEvaluationEntity, FlagStatusEnum, FlagTargetingRuleEntity, RuleOperatorEnum, featureFlagEntities, featureFlagsSchemaContribution };
+import{defineEntity as e,defineEntityEnum as t,field as n,index as r}from"@lssm/lib.schema";const i=t({name:`FlagStatus`,values:[`OFF`,`ON`,`GRADUAL`],schema:`lssm_feature_flags`,description:`Status of a feature flag.`}),a=t({name:`RuleOperator`,values:[`EQ`,`NEQ`,`IN`,`NIN`,`CONTAINS`,`NOT_CONTAINS`,`GT`,`GTE`,`LT`,`LTE`,`PERCENTAGE`],schema:`lssm_feature_flags`,description:`Operator for targeting rule conditions.`}),o=t({name:`ExperimentStatus`,values:[`DRAFT`,`RUNNING`,`PAUSED`,`COMPLETED`,`CANCELLED`],schema:`lssm_feature_flags`,description:`Status of an experiment.`}),s=e({name:`FeatureFlag`,description:`A feature flag for controlling feature availability.`,schema:`lssm_feature_flags`,map:`feature_flag`,fields:{id:n.id({description:`Unique flag identifier`}),key:n.string({isUnique:!0,description:`Flag key (e.g., new_dashboard)`}),name:n.string({description:`Human-readable name`}),description:n.string({isOptional:!0,description:`Description of the flag`}),status:n.enum(`FlagStatus`,{default:`OFF`,description:`Flag status`}),defaultValue:n.boolean({default:!1,description:`Default value when no rules match`}),variants:n.json({isOptional:!0,description:`Variant definitions for multivariate flags`}),orgId:n.string({isOptional:!0,description:`Organization scope (null = global)`}),tags:n.json({isOptional:!0,description:`Tags for categorization`}),metadata:n.json({isOptional:!0,description:`Additional metadata`}),createdAt:n.createdAt(),updatedAt:n.updatedAt(),targetingRules:n.hasMany(`FlagTargetingRule`),experiments:n.hasMany(`Experiment`),evaluations:n.hasMany(`FlagEvaluation`)},indexes:[r.on([`orgId`,`key`]),r.on([`status`])],enums:[i]}),c=e({name:`FlagTargetingRule`,description:`A targeting rule for conditional flag evaluation.`,schema:`lssm_feature_flags`,map:`flag_targeting_rule`,fields:{id:n.id({description:`Unique rule identifier`}),flagId:n.foreignKey({description:`Parent feature flag`}),name:n.string({isOptional:!0,description:`Rule name for debugging`}),priority:n.int({default:0,description:`Rule priority (lower = higher priority)`}),enabled:n.boolean({default:!0,description:`Whether rule is active`}),attribute:n.string({description:`Target attribute (userId, orgId, plan, segment, etc.)`}),operator:n.enum(`RuleOperator`,{description:`Comparison operator`}),value:n.json({description:`Target value(s)`}),rolloutPercentage:n.int({isOptional:!0,description:`Percentage for gradual rollout (0-100)`}),serveValue:n.boolean({isOptional:!0,description:`Boolean value to serve`}),serveVariant:n.string({isOptional:!0,description:`Variant key to serve (for multivariate)`}),createdAt:n.createdAt(),updatedAt:n.updatedAt(),flag:n.belongsTo(`FeatureFlag`,[`flagId`],[`id`],{onDelete:`Cascade`})},indexes:[r.on([`flagId`,`priority`]),r.on([`attribute`])],enums:[a]}),l=e({name:`Experiment`,description:`An A/B test experiment.`,schema:`lssm_feature_flags`,map:`experiment`,fields:{id:n.id({description:`Unique experiment identifier`}),key:n.string({isUnique:!0,description:`Experiment key`}),name:n.string({description:`Human-readable name`}),description:n.string({isOptional:!0,description:`Experiment description`}),hypothesis:n.string({isOptional:!0,description:`Experiment hypothesis`}),flagId:n.foreignKey({description:`Associated feature flag`}),status:n.enum(`ExperimentStatus`,{default:`DRAFT`,description:`Experiment status`}),variants:n.json({description:`Variant definitions with split ratios`}),metrics:n.json({isOptional:!0,description:`Metrics to track`}),audiencePercentage:n.int({default:100,description:`Percentage of audience to include`}),audienceFilter:n.json({isOptional:!0,description:`Audience filter criteria`}),scheduledStartAt:n.dateTime({isOptional:!0,description:`Scheduled start time`}),scheduledEndAt:n.dateTime({isOptional:!0,description:`Scheduled end time`}),startedAt:n.dateTime({isOptional:!0,description:`Actual start time`}),endedAt:n.dateTime({isOptional:!0,description:`Actual end time`}),winningVariant:n.string({isOptional:!0,description:`Declared winning variant`}),results:n.json({isOptional:!0,description:`Experiment results summary`}),orgId:n.string({isOptional:!0,description:`Organization scope`}),createdAt:n.createdAt(),updatedAt:n.updatedAt(),flag:n.belongsTo(`FeatureFlag`,[`flagId`],[`id`],{onDelete:`Cascade`}),assignments:n.hasMany(`ExperimentAssignment`)},indexes:[r.on([`status`]),r.on([`orgId`,`status`]),r.on([`flagId`])],enums:[o]}),u=e({name:`ExperimentAssignment`,description:`Tracks experiment variant assignments.`,schema:`lssm_feature_flags`,map:`experiment_assignment`,fields:{id:n.id({description:`Unique assignment identifier`}),experimentId:n.foreignKey({description:`Parent experiment`}),subjectType:n.string({description:`Subject type (user, org, session)`}),subjectId:n.string({description:`Subject identifier`}),variant:n.string({description:`Assigned variant key`}),bucket:n.int({description:`Hash bucket (0-99)`}),context:n.json({isOptional:!0,description:`Context at assignment time`}),assignedAt:n.dateTime({description:`Assignment timestamp`}),experiment:n.belongsTo(`Experiment`,[`experimentId`],[`id`],{onDelete:`Cascade`})},indexes:[r.unique([`experimentId`,`subjectType`,`subjectId`],{name:`experiment_assignment_unique`}),r.on([`subjectType`,`subjectId`])]}),d=e({name:`FlagEvaluation`,description:`Log of flag evaluations for debugging and analytics.`,schema:`lssm_feature_flags`,map:`flag_evaluation`,fields:{id:n.id({description:`Unique evaluation identifier`}),flagId:n.foreignKey({description:`Evaluated flag`}),flagKey:n.string({description:`Flag key (denormalized for queries)`}),subjectType:n.string({description:`Subject type (user, org, anonymous)`}),subjectId:n.string({description:`Subject identifier`}),result:n.boolean({description:`Evaluation result`}),variant:n.string({isOptional:!0,description:`Served variant (for multivariate)`}),matchedRuleId:n.string({isOptional:!0,description:`Rule that matched (if any)`}),reason:n.string({description:`Evaluation reason (default, rule, experiment, etc.)`}),context:n.json({isOptional:!0,description:`Evaluation context`}),evaluatedAt:n.dateTime({description:`Evaluation timestamp`}),flag:n.belongsTo(`FeatureFlag`,[`flagId`],[`id`],{onDelete:`Cascade`})},indexes:[r.on([`flagKey`,`evaluatedAt`]),r.on([`subjectType`,`subjectId`,`evaluatedAt`]),r.on([`flagId`,`evaluatedAt`])]}),f=[s,c,l,u,d],p={moduleId:`@lssm/lib.feature-flags`,entities:f,enums:[i,a,o]};export{u as ExperimentAssignmentEntity,l as ExperimentEntity,o as ExperimentStatusEnum,s as FeatureFlagEntity,d as FlagEvaluationEntity,i as FlagStatusEnum,c as FlagTargetingRuleEntity,a as RuleOperatorEnum,f as featureFlagEntities,p as featureFlagsSchemaContribution};

package/dist/evaluation/index.js

@@ -1,220 +1 @@
-//#region src/evaluation/index.ts
-/**
-* Simple hash function for consistent bucketing.
-* Uses a deterministic algorithm so the same input always produces the same bucket.
-*/
-function hashToBucket(value, seed = "") {
-	const input = `${seed}:${value}`;
-	let hash = 0;
-	for (let i = 0; i < input.length; i++) {
-		const char = input.charCodeAt(i);
-		hash = (hash << 5) - hash + char;
-		hash = hash & hash;
-	}
-	return Math.abs(hash % 100);
-}
-/**
-* Get subject identifier from context for consistent hashing.
-*/
-function getSubjectId(context) {
-	return context.userId || context.sessionId || context.orgId || "anonymous";
-}
-/**
-* Evaluate a single targeting rule condition.
-*/
-function evaluateRuleCondition(rule, context) {
-	const attributeValue = getAttributeValue(rule.attribute, context);
-	switch (rule.operator) {
-		case "EQ": return attributeValue === rule.value;
-		case "NEQ": return attributeValue !== rule.value;
-		case "IN":
-			if (!Array.isArray(rule.value)) return false;
-			return rule.value.includes(attributeValue);
-		case "NIN":
-			if (!Array.isArray(rule.value)) return true;
-			return !rule.value.includes(attributeValue);
-		case "CONTAINS":
-			if (typeof attributeValue !== "string" || typeof rule.value !== "string") return false;
-			return attributeValue.includes(rule.value);
-		case "NOT_CONTAINS":
-			if (typeof attributeValue !== "string" || typeof rule.value !== "string") return true;
-			return !attributeValue.includes(rule.value);
-		case "GT":
-			if (typeof attributeValue !== "number" || typeof rule.value !== "number") return false;
-			return attributeValue > rule.value;
-		case "GTE":
-			if (typeof attributeValue !== "number" || typeof rule.value !== "number") return false;
-			return attributeValue >= rule.value;
-		case "LT":
-			if (typeof attributeValue !== "number" || typeof rule.value !== "number") return false;
-			return attributeValue < rule.value;
-		case "LTE":
-			if (typeof attributeValue !== "number" || typeof rule.value !== "number") return false;
-			return attributeValue <= rule.value;
-		case "PERCENTAGE": return hashToBucket(getSubjectId(context), rule.attribute) < (typeof rule.value === "number" ? rule.value : 0);
-		default: return false;
-	}
-}
-/**
-* Get attribute value from context.
-*/
-function getAttributeValue(attribute, context) {
-	switch (attribute) {
-		case "userId": return context.userId;
-		case "orgId": return context.orgId;
-		case "plan": return context.plan;
-		case "segment": return context.segment;
-		case "sessionId": return context.sessionId;
-		default: return context.attributes?.[attribute];
-	}
-}
-/**
-* Feature flag evaluator.
-*
-* Evaluates flags based on:
-* 1. Flag status (OFF/ON/GRADUAL)
-* 2. Targeting rules (in priority order)
-* 3. Experiments (if running)
-* 4. Default value (fallback)
-*/
-var FlagEvaluator = class {
-	repository;
-	logger;
-	logEvaluations;
-	constructor(options) {
-		this.repository = options.repository;
-		this.logger = options.logger;
-		this.logEvaluations = options.logEvaluations ?? false;
-	}
-	/**
-	* Evaluate a feature flag.
-	*/
-	async evaluate(key, context) {
-		const orgId = context.orgId;
-		const flag = await this.repository.getFlag(key, orgId);
-		if (!flag) return this.makeResult(false, "FLAG_NOT_FOUND");
-		if (flag.status === "OFF") return this.logAndReturn(flag, context, this.makeResult(false, "FLAG_OFF"));
-		if (flag.status === "ON") return this.logAndReturn(flag, context, this.makeResult(true, "FLAG_ON"));
-		const sortedRules = [...await this.repository.getRules(flag.id)].filter((r) => r.enabled).sort((a, b) => a.priority - b.priority);
-		for (const rule of sortedRules) if (evaluateRuleCondition(rule, context)) {
-			if (rule.rolloutPercentage !== void 0 && rule.rolloutPercentage !== null) {
-				if (hashToBucket(getSubjectId(context), flag.key) >= rule.rolloutPercentage) continue;
-			}
-			const enabled = rule.serveValue ?? true;
-			return this.logAndReturn(flag, context, this.makeResult(enabled, "RULE_MATCH", rule.serveVariant, rule.id));
-		}
-		const experiment = await this.repository.getActiveExperiment(flag.id);
-		if (experiment && experiment.status === "RUNNING") {
-			const result = await this.evaluateExperiment(experiment, context);
-			if (result) return this.logAndReturn(flag, context, result);
-		}
-		return this.logAndReturn(flag, context, this.makeResult(flag.defaultValue, "DEFAULT_VALUE"));
-	}
-	/**
-	* Evaluate experiment and assign variant.
-	*/
-	async evaluateExperiment(experiment, context) {
-		const subjectId = getSubjectId(context);
-		const subjectType = context.userId ? "user" : context.orgId ? "org" : "session";
-		if (hashToBucket(subjectId, `${experiment.key}:audience`) >= experiment.audiencePercentage) return null;
-		let variant = await this.repository.getExperimentAssignment(experiment.id, subjectType, subjectId);
-		if (!variant) {
-			const variantBucket = hashToBucket(subjectId, experiment.key);
-			variant = this.assignVariant(experiment.variants, variantBucket);
-			await this.repository.saveExperimentAssignment(experiment.id, subjectType, subjectId, variant, variantBucket);
-		}
-		const enabled = variant !== "control";
-		return this.makeResult(enabled, "EXPERIMENT_VARIANT", variant, void 0, experiment.id);
-	}
-	/**
-	* Assign a variant based on bucket and variant percentages.
-	*/
-	assignVariant(variants, bucket) {
-		let cumulative = 0;
-		for (const variant of variants) {
-			cumulative += variant.percentage;
-			if (bucket < cumulative) return variant.key;
-		}
-		return variants[variants.length - 1]?.key ?? "control";
-	}
-	/**
-	* Create evaluation result.
-	*/
-	makeResult(enabled, reason, variant, ruleId, experimentId) {
-		return {
-			enabled,
-			variant,
-			reason,
-			ruleId,
-			experimentId
-		};
-	}
-	/**
-	* Log evaluation and return result.
-	*/
-	logAndReturn(flag, context, result) {
-		if (this.logEvaluations && this.logger) {
-			const subjectId = getSubjectId(context);
-			const subjectType = context.userId ? "user" : context.orgId ? "org" : "session";
-			this.logger.log({
-				flagId: flag.id,
-				flagKey: flag.key,
-				subjectType,
-				subjectId,
-				result: result.enabled,
-				variant: result.variant,
-				reason: result.reason,
-				ruleId: result.ruleId,
-				experimentId: result.experimentId,
-				context
-			});
-		}
-		return result;
-	}
-};
-/**
-* In-memory flag repository for testing and development.
-*/
-var InMemoryFlagRepository = class {
-	flags = /* @__PURE__ */ new Map();
-	rules = /* @__PURE__ */ new Map();
-	experiments = /* @__PURE__ */ new Map();
-	assignments = /* @__PURE__ */ new Map();
-	addFlag(flag) {
-		this.flags.set(flag.key, flag);
-	}
-	addRule(flagId, rule) {
-		const existing = this.rules.get(flagId) || [];
-		existing.push(rule);
-		this.rules.set(flagId, existing);
-	}
-	addExperiment(experiment, flagId) {
-		this.experiments.set(flagId, experiment);
-	}
-	async getFlag(key) {
-		return this.flags.get(key) || null;
-	}
-	async getRules(flagId) {
-		return this.rules.get(flagId) || [];
-	}
-	async getActiveExperiment(flagId) {
-		return this.experiments.get(flagId) || null;
-	}
-	async getExperimentAssignment(experimentId, subjectType, subjectId) {
-		const key = `${experimentId}:${subjectType}:${subjectId}`;
-		return this.assignments.get(key) || null;
-	}
-	async saveExperimentAssignment(experimentId, subjectType, subjectId, variant) {
-		const key = `${experimentId}:${subjectType}:${subjectId}`;
-		this.assignments.set(key, variant);
-	}
-	clear() {
-		this.flags.clear();
-		this.rules.clear();
-		this.experiments.clear();
-		this.assignments.clear();
-	}
-};
-
-//#endregion
-export { FlagEvaluator, InMemoryFlagRepository, evaluateRuleCondition, getSubjectId, hashToBucket };
+function e(e,t=``){let n=`${t}:${e}`,r=0;for(let e=0;e<n.length;e++){let t=n.charCodeAt(e);r=(r<<5)-r+t,r&=r}return Math.abs(r%100)}function t(e){return e.userId||e.sessionId||e.orgId||`anonymous`}function n(n,i){let a=r(n.attribute,i);switch(n.operator){case`EQ`:return a===n.value;case`NEQ`:return a!==n.value;case`IN`:return Array.isArray(n.value)?n.value.includes(a):!1;case`NIN`:return Array.isArray(n.value)?!n.value.includes(a):!0;case`CONTAINS`:return typeof a!=`string`||typeof n.value!=`string`?!1:a.includes(n.value);case`NOT_CONTAINS`:return typeof a!=`string`||typeof n.value!=`string`?!0:!a.includes(n.value);case`GT`:return typeof a!=`number`||typeof n.value!=`number`?!1:a>n.value;case`GTE`:return typeof a!=`number`||typeof n.value!=`number`?!1:a>=n.value;case`LT`:return typeof a!=`number`||typeof n.value!=`number`?!1:a<n.value;case`LTE`:return typeof a!=`number`||typeof n.value!=`number`?!1:a<=n.value;case`PERCENTAGE`:return e(t(i),n.attribute)<(typeof n.value==`number`?n.value:0);default:return!1}}function r(e,t){switch(e){case`userId`:return t.userId;case`orgId`:return t.orgId;case`plan`:return t.plan;case`segment`:return t.segment;case`sessionId`:return t.sessionId;default:return t.attributes?.[e]}}var i=class{repository;logger;logEvaluations;constructor(e){this.repository=e.repository,this.logger=e.logger,this.logEvaluations=e.logEvaluations??!1}async evaluate(r,i){let a=i.orgId,o=await this.repository.getFlag(r,a);if(!o)return this.makeResult(!1,`FLAG_NOT_FOUND`);if(o.status===`OFF`)return this.logAndReturn(o,i,this.makeResult(!1,`FLAG_OFF`));if(o.status===`ON`)return this.logAndReturn(o,i,this.makeResult(!0,`FLAG_ON`));let s=[...await this.repository.getRules(o.id)].filter(e=>e.enabled).sort((e,t)=>e.priority-t.priority);for(let r of s)if(n(r,i)){if(r.rolloutPercentage!==void 0&&r.rolloutPercentage!==null&&e(t(i),o.key)>=r.rolloutPercentage)continue;let n=r.serveValue??!0;return this.logAndReturn(o,i,this.makeResult(n,`RULE_MATCH`,r.serveVariant,r.id))}let c=await this.repository.getActiveExperiment(o.id);if(c&&c.status===`RUNNING`){let e=await this.evaluateExperiment(c,i);if(e)return this.logAndReturn(o,i,e)}return this.logAndReturn(o,i,this.makeResult(o.defaultValue,`DEFAULT_VALUE`))}async evaluateExperiment(n,r){let i=t(r),a=r.userId?`user`:r.orgId?`org`:`session`;if(e(i,`${n.key}:audience`)>=n.audiencePercentage)return null;let o=await this.repository.getExperimentAssignment(n.id,a,i);if(!o){let t=e(i,n.key);o=this.assignVariant(n.variants,t),await this.repository.saveExperimentAssignment(n.id,a,i,o,t)}let s=o!==`control`;return this.makeResult(s,`EXPERIMENT_VARIANT`,o,void 0,n.id)}assignVariant(e,t){let n=0;for(let r of e)if(n+=r.percentage,t<n)return r.key;return e[e.length-1]?.key??`control`}makeResult(e,t,n,r,i){return{enabled:e,variant:n,reason:t,ruleId:r,experimentId:i}}logAndReturn(e,n,r){if(this.logEvaluations&&this.logger){let i=t(n),a=n.userId?`user`:n.orgId?`org`:`session`;this.logger.log({flagId:e.id,flagKey:e.key,subjectType:a,subjectId:i,result:r.enabled,variant:r.variant,reason:r.reason,ruleId:r.ruleId,experimentId:r.experimentId,context:n})}return r}},a=class{flags=new Map;rules=new Map;experiments=new Map;assignments=new Map;addFlag(e){this.flags.set(e.key,e)}addRule(e,t){let n=this.rules.get(e)||[];n.push(t),this.rules.set(e,n)}addExperiment(e,t){this.experiments.set(t,e)}async getFlag(e){return this.flags.get(e)||null}async getRules(e){return this.rules.get(e)||[]}async getActiveExperiment(e){return this.experiments.get(e)||null}async getExperimentAssignment(e,t,n){let r=`${e}:${t}:${n}`;return this.assignments.get(r)||null}async saveExperimentAssignment(e,t,n,r){let i=`${e}:${t}:${n}`;this.assignments.set(i,r)}clear(){this.flags.clear(),this.rules.clear(),this.experiments.clear(),this.assignments.clear()}};export{i as FlagEvaluator,a as InMemoryFlagRepository,n as evaluateRuleCondition,t as getSubjectId,e as hashToBucket};