@happyvertical/smrt-features 0.30.0

package/dist/index.js

@@ -0,0 +1,727 @@
+import { ObjectRegistry, isQualifiedName, parseQualifiedName, createQualifiedName, smrt, SmrtObject, SmrtCollection } from "@happyvertical/smrt-core";
+import { GLOBAL_FEATURE_SCOPE_ID, FeatureOverrideEffect } from "./types.js";
+import { importWorkspaceModule } from "@happyvertical/smrt-core/utils/import-workspace-module";
+ObjectRegistry.registerPackageManifest(
+  new URL("./manifest.json", import.meta.url)
+);
+function createFeatureKey(qualifiedClassName, localId) {
+  if (!isQualifiedName(qualifiedClassName)) {
+    throw new Error(
+      `Feature keys require a qualified class name. Received "${qualifiedClassName}".`
+    );
+  }
+  if (!localId) {
+    throw new Error("Feature localId is required.");
+  }
+  if (localId.includes("#")) {
+    throw new Error(
+      `Feature localId "${localId}" cannot contain "#". This character is reserved for canonical feature keys.`
+    );
+  }
+  return `${qualifiedClassName}#${localId}`;
+}
+function parseFeatureKey(featureKey) {
+  const separatorIndex = featureKey.lastIndexOf("#");
+  if (separatorIndex <= 0 || separatorIndex === featureKey.length - 1) {
+    throw new Error(
+      `Invalid feature key "${featureKey}". Expected format "<qualifiedClassName>#<localId>".`
+    );
+  }
+  const qualifiedClassName = featureKey.slice(0, separatorIndex);
+  const localId = featureKey.slice(separatorIndex + 1);
+  if (!isQualifiedName(qualifiedClassName)) {
+    throw new Error(
+      `Invalid feature key "${featureKey}". "${qualifiedClassName}" is not a qualified class name.`
+    );
+  }
+  return { qualifiedClassName, localId };
+}
+function serializeFeatureMetadata(metadata) {
+  if (!metadata) {
+    return "";
+  }
+  if (typeof metadata === "string") {
+    const parsed = parseFeatureMetadataString(metadata);
+    return JSON.stringify(parsed);
+  }
+  if (!isFeatureMetadataRecord(metadata)) {
+    throw new Error(
+      "Feature metadata must be a plain object or a JSON string representing a plain object."
+    );
+  }
+  return JSON.stringify(metadata);
+}
+function parseFeatureMetadata(metadata) {
+  if (!metadata) {
+    return {};
+  }
+  try {
+    return parseFeatureMetadataString(metadata);
+  } catch {
+    return {};
+  }
+}
+function parseFeatureMetadataString(metadata) {
+  let parsed;
+  try {
+    parsed = JSON.parse(metadata);
+  } catch (error) {
+    throw new Error(
+      "Feature metadata must be a plain object or a JSON string representing a plain object.",
+      { cause: error }
+    );
+  }
+  if (!isFeatureMetadataRecord(parsed)) {
+    throw new Error(
+      "Feature metadata must be a plain object or a JSON string representing a plain object."
+    );
+  }
+  return parsed;
+}
+function isFeatureMetadataRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function getQualifiedClassNameFromRegistry(registration) {
+  if (registration.qualifiedName && isQualifiedName(registration.qualifiedName)) {
+    return registration.qualifiedName;
+  }
+  if (registration.packageName) {
+    return createQualifiedName(registration.packageName, registration.name);
+  }
+  return null;
+}
+function getPackageNameFromRegistry(registration) {
+  if (registration.packageName) {
+    return registration.packageName;
+  }
+  const qualifiedClassName = getQualifiedClassNameFromRegistry(registration);
+  if (!qualifiedClassName) {
+    return null;
+  }
+  return parseQualifiedName(qualifiedClassName).packageName;
+}
+function extractFeatureSeedsFromRegistryEntry(registration) {
+  if (registration.visibility === "test") {
+    return [];
+  }
+  const qualifiedClassName = getQualifiedClassNameFromRegistry(registration);
+  if (!qualifiedClassName) {
+    return [];
+  }
+  const featureConfig = registration.config.features;
+  if (!featureConfig) {
+    return [];
+  }
+  const packageName = registration.packageName || parseQualifiedName(qualifiedClassName).packageName;
+  return Object.entries(featureConfig).map(([localId, feature]) => ({
+    featureKey: createFeatureKey(qualifiedClassName, localId),
+    packageName,
+    qualifiedClassName,
+    className: registration.name,
+    localId,
+    defaultEnabled: feature.defaultEnabled,
+    label: feature.label,
+    description: feature.description,
+    metadata: feature.metadata,
+    visibility: registration.visibility
+  }));
+}
+function extractFeatureSeedsFromManifest(manifest) {
+  const seeds = [];
+  for (const [objectKey, objectDef] of Object.entries(manifest.objects)) {
+    seeds.push(...extractFeatureSeedsFromManifestObject(objectKey, objectDef));
+  }
+  return seeds;
+}
+function extractTouchedPackagesFromManifest(manifest) {
+  const packages = /* @__PURE__ */ new Set();
+  if (manifest.packageName) {
+    packages.add(manifest.packageName);
+  }
+  for (const [objectKey, objectDef] of Object.entries(manifest.objects)) {
+    if (objectDef.visibility === "test") {
+      continue;
+    }
+    if (objectDef.packageName) {
+      packages.add(objectDef.packageName);
+      continue;
+    }
+    const qualifiedClassName = resolveManifestQualifiedClassName(
+      objectKey,
+      objectDef
+    );
+    if (qualifiedClassName) {
+      packages.add(parseQualifiedName(qualifiedClassName).packageName);
+    }
+  }
+  return packages;
+}
+function extractFeatureSeedsFromManifestObject(objectKey, objectDef) {
+  if (objectDef.visibility === "test") {
+    return [];
+  }
+  const features = objectDef.decoratorConfig.features;
+  if (!features) {
+    return [];
+  }
+  const qualifiedClassName = resolveManifestQualifiedClassName(
+    objectKey,
+    objectDef
+  );
+  if (!qualifiedClassName) {
+    return [];
+  }
+  const packageName = objectDef.packageName || parseQualifiedName(qualifiedClassName).packageName;
+  return Object.entries(features).map(([localId, feature]) => ({
+    featureKey: createFeatureKey(qualifiedClassName, localId),
+    packageName,
+    qualifiedClassName,
+    className: objectDef.className,
+    localId,
+    defaultEnabled: feature.defaultEnabled,
+    label: feature.label,
+    description: feature.description,
+    metadata: feature.metadata && typeof feature.metadata === "object" ? feature.metadata : void 0,
+    visibility: objectDef.visibility
+  }));
+}
+function resolveManifestQualifiedClassName(objectKey, objectDef) {
+  if (objectDef.qualifiedName && isQualifiedName(objectDef.qualifiedName)) {
+    return objectDef.qualifiedName;
+  }
+  if (isQualifiedName(objectKey)) {
+    return objectKey;
+  }
+  if (objectDef.packageName) {
+    return createQualifiedName(objectDef.packageName, objectDef.className);
+  }
+  return null;
+}
+function resolveFeatureKeyForTarget(classOrInstance, localId) {
+  const ctor = typeof classOrInstance === "function" ? classOrInstance : classOrInstance.constructor;
+  const registration = ObjectRegistry.getClassByConstructor(ctor);
+  if (!registration) {
+    throw new Error(
+      `Cannot resolve feature "${localId}" because ${ctor?.name || "the target class"} is not registered with @smrt().`
+    );
+  }
+  const qualifiedClassName = getQualifiedClassNameFromRegistry(registration);
+  if (!qualifiedClassName) {
+    throw new Error(
+      `Cannot resolve feature "${localId}" for ${registration.name} because the class has no qualified package identity.`
+    );
+  }
+  const feature = registration.config.features?.[localId];
+  if (!feature) {
+    throw new Error(
+      `Feature "${localId}" is not declared on ${qualifiedClassName}.`
+    );
+  }
+  return {
+    featureKey: createFeatureKey(qualifiedClassName, localId),
+    defaultEnabled: feature.defaultEnabled
+  };
+}
+function findFeatureDefaultInRegistry(featureKey) {
+  const { qualifiedClassName, localId } = parseFeatureKey(featureKey);
+  const registration = ObjectRegistry.getClassByQualifiedName(qualifiedClassName) || ObjectRegistry.getClass(qualifiedClassName);
+  const feature = registration?.config.features?.[localId];
+  return feature?.defaultEnabled;
+}
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+let FeatureDefinition = class extends SmrtObject {
+  featureKey = "";
+  packageName = "";
+  qualifiedClassName = "";
+  className = "";
+  localId = "";
+  defaultEnabled = false;
+  label = "";
+  description = "";
+  metadata = "";
+  visibility = "public";
+  constructor(options = {}) {
+    super(options);
+    if (options.featureKey !== void 0) this.featureKey = options.featureKey;
+    if (options.packageName !== void 0)
+      this.packageName = options.packageName;
+    if (options.qualifiedClassName !== void 0) {
+      this.qualifiedClassName = options.qualifiedClassName;
+    }
+    if (options.className !== void 0) this.className = options.className;
+    if (options.localId !== void 0) this.localId = options.localId;
+    if (options.defaultEnabled !== void 0) {
+      this.defaultEnabled = options.defaultEnabled;
+    }
+    if (options.label !== void 0) this.label = options.label;
+    if (options.description !== void 0)
+      this.description = options.description;
+    if (options.visibility !== void 0) this.visibility = options.visibility;
+    if (options.metadata !== void 0) {
+      this.metadata = serializeFeatureMetadata(options.metadata);
+    }
+  }
+  getMetadata() {
+    return parseFeatureMetadata(this.metadata);
+  }
+  setMetadata(metadata) {
+    this.metadata = serializeFeatureMetadata(metadata);
+  }
+};
+FeatureDefinition = __decorateClass$1([
+  smrt({
+    tableName: "_smrt_feature_definitions",
+    api: { include: ["list", "get"] },
+    cli: { include: ["list", "get"], exclude: ["getMetadata", "setMetadata"] },
+    mcp: { include: ["list", "get"], exclude: ["getMetadata", "setMetadata"] },
+    conflictColumns: ["feature_key"]
+  })
+], FeatureDefinition);
+class FeatureDefinitionCollection extends SmrtCollection {
+  static _itemClass = FeatureDefinition;
+  async findByFeatureKey(featureKey) {
+    const results = await this.list({
+      where: { featureKey },
+      limit: 1
+    });
+    return results[0] ?? null;
+  }
+  async findByPackageName(packageName) {
+    return this.list({
+      where: { packageName }
+    });
+  }
+  async upsertDefinition(seed) {
+    const existing = await this.findByFeatureKey(seed.featureKey);
+    if (!existing) {
+      const created = await this.create({
+        ...seed,
+        metadata: serializeFeatureMetadata(seed.metadata)
+      });
+      await created.save();
+      return { definition: created, status: "created" };
+    }
+    const nextMetadata = serializeFeatureMetadata(seed.metadata);
+    const changed = existing.packageName !== seed.packageName || existing.qualifiedClassName !== seed.qualifiedClassName || existing.className !== seed.className || existing.localId !== seed.localId || existing.defaultEnabled !== seed.defaultEnabled || existing.label !== (seed.label ?? "") || existing.description !== (seed.description ?? "") || existing.metadata !== nextMetadata || existing.visibility !== (seed.visibility ?? "public");
+    if (!changed) {
+      return { definition: existing, status: "unchanged" };
+    }
+    existing.packageName = seed.packageName;
+    existing.qualifiedClassName = seed.qualifiedClassName;
+    existing.className = seed.className;
+    existing.localId = seed.localId;
+    existing.defaultEnabled = seed.defaultEnabled;
+    existing.label = seed.label ?? "";
+    existing.description = seed.description ?? "";
+    existing.metadata = nextMetadata;
+    existing.visibility = seed.visibility ?? "public";
+    await existing.save();
+    return { definition: existing, status: "updated" };
+  }
+}
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+let FeatureOverride = class extends SmrtObject {
+  featureKey = "";
+  scopeType = "global";
+  scopeId = GLOBAL_FEATURE_SCOPE_ID;
+  effect = FeatureOverrideEffect.INHERIT;
+  constructor(options = {}) {
+    super(options);
+    if (options.featureKey !== void 0) this.featureKey = options.featureKey;
+    if (options.scopeType !== void 0) this.scopeType = options.scopeType;
+    if (options.scopeId !== void 0) this.scopeId = options.scopeId;
+    if (options.effect !== void 0) this.effect = options.effect;
+  }
+  isInherit() {
+    return this.effect === FeatureOverrideEffect.INHERIT;
+  }
+  isEnabled() {
+    return this.effect === FeatureOverrideEffect.ENABLE;
+  }
+  isDisabled() {
+    return this.effect === FeatureOverrideEffect.DISABLE;
+  }
+};
+FeatureOverride = __decorateClass([
+  smrt({
+    tableName: "_smrt_feature_overrides",
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    cli: {
+      exclude: ["isInherit", "isEnabled", "isDisabled"]
+    },
+    mcp: {
+      exclude: ["isInherit", "isEnabled", "isDisabled"]
+    },
+    conflictColumns: ["feature_key", "scope_type", "scope_id"]
+  })
+], FeatureOverride);
+class FeatureOverrideCollection extends SmrtCollection {
+  static _itemClass = FeatureOverride;
+  async findByFeatureKey(featureKey) {
+    return this.list({
+      where: { featureKey }
+    });
+  }
+  async findByFeatureAndScope(featureKey, scopeType, scopeId) {
+    const results = await this.list({
+      where: { featureKey, scopeType, scopeId },
+      limit: 1
+    });
+    return results[0] ?? null;
+  }
+  async getGlobalOverride(featureKey) {
+    return this.findByFeatureAndScope(
+      featureKey,
+      "global",
+      GLOBAL_FEATURE_SCOPE_ID
+    );
+  }
+  async getTenantOverride(featureKey, tenantId) {
+    return this.findByFeatureAndScope(featureKey, "tenant", tenantId);
+  }
+  async getOverrideMap(featureKey, scopeType, scopeIds) {
+    const result = /* @__PURE__ */ new Map();
+    if (scopeIds.length === 0) {
+      return result;
+    }
+    const overrides = await this.list({
+      where: { featureKey, scopeType, scopeId: scopeIds }
+    });
+    for (const override of overrides) {
+      result.set(override.scopeId, override);
+    }
+    return result;
+  }
+  async setOverride(featureKey, scopeType, scopeId, effect) {
+    const existing = await this.findByFeatureAndScope(
+      featureKey,
+      scopeType,
+      scopeId
+    );
+    if (existing) {
+      existing.effect = effect;
+      await existing.save();
+      return existing;
+    }
+    const created = await this.create({
+      featureKey,
+      scopeType,
+      scopeId,
+      effect
+    });
+    await created.save();
+    return created;
+  }
+  async setGlobalOverride(featureKey, effect) {
+    return this.setOverride(
+      featureKey,
+      "global",
+      GLOBAL_FEATURE_SCOPE_ID,
+      effect
+    );
+  }
+  async setTenantOverride(featureKey, tenantId, effect) {
+    return this.setOverride(featureKey, "tenant", tenantId, effect);
+  }
+  async removeOverride(featureKey, scopeType, scopeId) {
+    const existing = await this.findByFeatureAndScope(
+      featureKey,
+      scopeType,
+      scopeId
+    );
+    if (!existing) {
+      return false;
+    }
+    await existing.delete();
+    return true;
+  }
+}
+class FeatureResolver {
+  options;
+  resolverOptions;
+  featureDefinitions;
+  featureOverrides;
+  initializationPromise = null;
+  tenantHierarchyPromise = null;
+  constructor(options = {}, resolverOptions = {}) {
+    this.options = options;
+    this.resolverOptions = resolverOptions;
+  }
+  async isEnabled(featureKey, context = {}) {
+    await this.ensureInitialized();
+    const baseState = await this.resolveBaseState(featureKey);
+    const globalOverride = await this.featureOverrides.getGlobalOverride(featureKey);
+    const globalState = this.applyOverride(baseState, globalOverride?.effect);
+    if (!context.tenantId) {
+      return globalState;
+    }
+    const tenantHierarchy = await this.getTenantHierarchy();
+    if (!tenantHierarchy) {
+      const directOverride = await this.featureOverrides.getTenantOverride(
+        featureKey,
+        context.tenantId
+      );
+      return this.applyOverride(globalState, directOverride?.effect);
+    }
+    const chain = await tenantHierarchy.getChain(context.tenantId);
+    if (chain.length === 0) {
+      const directOverride = await this.featureOverrides.getTenantOverride(
+        featureKey,
+        context.tenantId
+      );
+      return this.applyOverride(globalState, directOverride?.effect);
+    }
+    const overrides = await this.featureOverrides.getOverrideMap(
+      featureKey,
+      "tenant",
+      chain.map((node) => node.id)
+    );
+    let inheritedState = globalState;
+    for (let index = 0; index < chain.length; index++) {
+      const current = chain[index];
+      const previous = index > 0 ? chain[index - 1] : null;
+      const shouldInherit = index === 0 || !!previous?.cascadePermissions && current.inheritPermissions;
+      const baseline = shouldInherit ? inheritedState : globalState;
+      const override = overrides.get(current.id);
+      inheritedState = this.applyOverride(baseline, override?.effect);
+    }
+    return inheritedState;
+  }
+  async isEnabledFor(classOrInstance, localId, context = {}) {
+    const { featureKey } = resolveFeatureKeyForTarget(classOrInstance, localId);
+    return this.isEnabled(featureKey, context);
+  }
+  async ensureInitialized() {
+    if (!this.initializationPromise) {
+      this.initializationPromise = (async () => {
+        this.featureDefinitions = await FeatureDefinitionCollection.create(this.options);
+        this.featureOverrides = await FeatureOverrideCollection.create(
+          this.options
+        );
+      })();
+    }
+    await this.initializationPromise;
+  }
+  async resolveBaseState(featureKey) {
+    const registryDefault = findFeatureDefaultInRegistry(featureKey);
+    if (registryDefault !== void 0) {
+      return registryDefault;
+    }
+    const definition = await this.featureDefinitions.findByFeatureKey(featureKey);
+    if (!definition) {
+      throw new Error(
+        `Feature "${featureKey}" is not declared in the registry or synced feature definitions.`
+      );
+    }
+    return definition.defaultEnabled;
+  }
+  applyOverride(currentState, effect) {
+    switch (effect) {
+      case FeatureOverrideEffect.ENABLE:
+        return true;
+      case FeatureOverrideEffect.DISABLE:
+        return false;
+      default:
+        return currentState;
+    }
+  }
+  async getTenantHierarchy() {
+    if (!this.tenantHierarchyPromise) {
+      const loader = this.resolverOptions.tenantHierarchyLoader || defaultTenantHierarchyLoader;
+      this.tenantHierarchyPromise = loader(this.options);
+    }
+    return this.tenantHierarchyPromise;
+  }
+}
+async function defaultTenantHierarchyLoader(options) {
+  try {
+    const usersModule = await importWorkspaceModule({
+      packageName: "@happyvertical/smrt-users",
+      sourceEntry: "packages/users/src/collections/index.ts",
+      purpose: "tenant-aware feature flag resolution"
+    });
+    const tenantCollection = await usersModule.TenantCollection.create(options);
+    return {
+      async getChain(tenantId) {
+        const tenant = await tenantCollection.get({ id: tenantId });
+        if (!tenant) {
+          return [];
+        }
+        const ancestors = await tenantCollection.getAncestorsFromRoot(tenantId);
+        return [...ancestors, tenant].map((node) => ({
+          id: String(node.id),
+          inheritPermissions: Boolean(node.inheritPermissions),
+          cascadePermissions: Boolean(node.cascadePermissions)
+        }));
+      }
+    };
+  } catch (error) {
+    if (isMissingUsersDependency(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+function isMissingUsersDependency(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const causeMessage = error.cause instanceof Error ? ` ${error.cause.message}` : "";
+  const text = `${error.message}${causeMessage}`;
+  return text.includes("@happyvertical/smrt-users") && (text.includes("Cannot find module") || text.includes("Failed to load") || text.includes("could not find"));
+}
+class FeatureSyncService {
+  options;
+  featureDefinitions;
+  initializationPromise = null;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async syncDefinitions(options = {}) {
+    await this.ensureInitialized();
+    const registrations = this.collectRegistrations(options);
+    const definitions = this.collectDefinitionsFromRegistrations(registrations);
+    const touchedPackages = this.collectTouchedPackagesFromRegistrations(registrations);
+    const isFilteredSync = Boolean(options.classNames?.length) || Boolean(options.constructors?.length);
+    const pruneStale = isFilteredSync ? false : options.pruneStale ?? true;
+    return this.applyDefinitions(definitions, touchedPackages, pruneStale);
+  }
+  async syncManifest(manifest, options = {}) {
+    await this.ensureInitialized();
+    const definitions = extractFeatureSeedsFromManifest(manifest);
+    const touchedPackages = extractTouchedPackagesFromManifest(manifest);
+    return this.applyDefinitions(
+      definitions,
+      touchedPackages,
+      options.pruneStale ?? true
+    );
+  }
+  async ensureInitialized() {
+    if (!this.initializationPromise) {
+      this.initializationPromise = (async () => {
+        this.featureDefinitions = await FeatureDefinitionCollection.create(this.options);
+      })();
+    }
+    await this.initializationPromise;
+  }
+  collectDefinitionsFromRegistrations(registrations) {
+    const definitions = [];
+    for (const registration of registrations) {
+      definitions.push(...extractFeatureSeedsFromRegistryEntry(registration));
+    }
+    return definitions;
+  }
+  collectTouchedPackagesFromRegistrations(registrations) {
+    const packages = /* @__PURE__ */ new Set();
+    for (const registration of registrations) {
+      if (registration.visibility === "test") {
+        continue;
+      }
+      const packageName = getPackageNameFromRegistry(registration);
+      if (packageName) {
+        packages.add(packageName);
+      }
+    }
+    return packages;
+  }
+  collectRegistrations(options) {
+    if (options.classNames?.length) {
+      return options.classNames.map((name) => ObjectRegistry.getClass(name)).filter((value) => !!value);
+    }
+    if (options.constructors?.length) {
+      return options.constructors.map((ctor) => ObjectRegistry.getClassByConstructor(ctor)).filter((value) => !!value);
+    }
+    const registrations = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const registration of ObjectRegistry.getAllClasses().values()) {
+      if (seen.has(registration)) {
+        continue;
+      }
+      seen.add(registration);
+      registrations.push(registration);
+    }
+    return registrations;
+  }
+  async applyDefinitions(definitions, touchedPackages, pruneStale) {
+    const deduped = /* @__PURE__ */ new Map();
+    for (const definition of definitions) {
+      deduped.set(definition.featureKey, definition);
+    }
+    let created = 0;
+    let updated = 0;
+    let unchanged = 0;
+    let deleted = 0;
+    const dedupedDefinitions = Array.from(deduped.values());
+    const currentKeys = new Set(
+      dedupedDefinitions.map((definition) => definition.featureKey)
+    );
+    const upsertResults = await Promise.all(
+      dedupedDefinitions.map(
+        (definition) => this.featureDefinitions.upsertDefinition(definition)
+      )
+    );
+    for (const result of upsertResults) {
+      if (result.status === "created") created++;
+      if (result.status === "updated") updated++;
+      if (result.status === "unchanged") unchanged++;
+    }
+    if (pruneStale) {
+      const existingByPackage = await Promise.all(
+        Array.from(
+          touchedPackages,
+          (packageName) => this.featureDefinitions.findByPackageName(packageName)
+        )
+      );
+      const staleDefinitions = existingByPackage.flatMap(
+        (existing) => existing.filter(
+          (definition) => !currentKeys.has(definition.featureKey)
+        )
+      );
+      await Promise.all(
+        staleDefinitions.map((definition) => definition.delete())
+      );
+      deleted = staleDefinitions.length;
+    }
+    return {
+      total: deduped.size,
+      created,
+      updated,
+      unchanged,
+      deleted,
+      featureKeys: Array.from(currentKeys).sort()
+    };
+  }
+}
+export {
+  FeatureDefinition,
+  FeatureDefinitionCollection,
+  FeatureOverride,
+  FeatureOverrideCollection,
+  FeatureOverrideEffect,
+  FeatureResolver,
+  FeatureSyncService,
+  GLOBAL_FEATURE_SCOPE_ID,
+  createFeatureKey,
+  findFeatureDefaultInRegistry,
+  parseFeatureKey,
+  resolveFeatureKeyForTarget
+};
+//# sourceMappingURL=index.js.map