@remnic/core 9.3.655 → 9.3.656

package/dist/{chunk-KOI765XP.js → chunk-CTAV55JM.js}

@@ -373,6 +373,228 @@ var LEGACY_ACTIVE_RECALL_CUSTOM_FIELD = [
   "Prompt",
   "Override"
 ].join("");
+var SCOPE_PROFILE_LAYER_IDS = [
+  "userProject",
+  "teamProject",
+  "userGlobal",
+  "serverShared"
+];
+var SCOPE_PROFILE_PROMOTION_TARGETS = [
+  ...SCOPE_PROFILE_LAYER_IDS
+];
+var SCOPE_PROFILE_AUTO_PROMOTE_CATEGORIES = [
+  "fact",
+  "correction",
+  "decision",
+  "preference",
+  "rule",
+  "procedure"
+];
+var CONFIDENCE_TIERS = [
+  "explicit",
+  "implied",
+  "inferred",
+  "speculative"
+];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseStringList(value, keyName) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) {
+    throw new Error(keyName + " must be an array");
+  }
+  const out = [];
+  for (const entry of value) {
+    if (typeof entry !== "string" || entry.length === 0) {
+      throw new Error(keyName + " must contain only non-empty strings");
+    }
+    out.push(entry);
+  }
+  return out;
+}
+function parseScopeProfileLayerList(value, keyName, fallback) {
+  if (value === void 0 || value === null) return [...fallback];
+  if (!Array.isArray(value)) {
+    throw new Error(`${keyName} must be an array`);
+  }
+  const out = [];
+  for (const entry of value) {
+    if (!SCOPE_PROFILE_LAYER_IDS.includes(entry)) {
+      throw new Error(`${keyName} contains unsupported layer: ${String(entry)}`);
+    }
+    if (!out.includes(entry)) {
+      out.push(entry);
+    }
+  }
+  return out;
+}
+function parseScopeProfilePromotionTargets(value, keyName) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) {
+    throw new Error(`${keyName} must be an array`);
+  }
+  const out = [];
+  for (const entry of value) {
+    if (!SCOPE_PROFILE_PROMOTION_TARGETS.includes(entry)) {
+      throw new Error(`${keyName} contains unsupported target: ${String(entry)}`);
+    }
+    if (!out.includes(entry)) {
+      out.push(entry);
+    }
+  }
+  return out;
+}
+function parseScopeProfiles(value) {
+  if (value === void 0 || value === null) return {};
+  if (!isRecord(value)) {
+    throw new Error("scopeProfiles must be an object");
+  }
+  const profiles = {};
+  for (const [profileId, rawProfile] of Object.entries(value)) {
+    if (profileId.trim().length === 0) {
+      throw new Error("scopeProfiles keys must not be empty");
+    }
+    if (!isRecord(rawProfile)) {
+      throw new Error(`scopeProfiles.${profileId} must be an object`);
+    }
+    const readOrder = parseScopeProfileLayerList(
+      rawProfile.readOrder,
+      `scopeProfiles.${profileId}.readOrder`,
+      ["userProject", "userGlobal", "serverShared"]
+    );
+    const writeDefault = rawProfile.writeDefault === void 0 || rawProfile.writeDefault === null ? "userProject" : rawProfile.writeDefault;
+    if (!SCOPE_PROFILE_LAYER_IDS.includes(writeDefault)) {
+      throw new Error(`scopeProfiles.${profileId}.writeDefault contains unsupported layer: ${String(writeDefault)}`);
+    }
+    if (rawProfile.teamProject !== void 0 && rawProfile.teamProject !== null && !isRecord(rawProfile.teamProject)) {
+      throw new Error("scopeProfiles." + profileId + ".teamProject must be an object");
+    }
+    const teamProject = (() => {
+      if (!isRecord(rawProfile.teamProject)) return void 0;
+      const out = {};
+      if (rawProfile.teamProject.namespaceTemplate !== void 0) {
+        if (typeof rawProfile.teamProject.namespaceTemplate !== "string" || rawProfile.teamProject.namespaceTemplate.length === 0) {
+          throw new Error(
+            `scopeProfiles.${profileId}.teamProject.namespaceTemplate must be a non-empty string`
+          );
+        }
+        out.namespaceTemplate = rawProfile.teamProject.namespaceTemplate;
+      }
+      if (rawProfile.teamProject.teamId !== void 0) {
+        if (typeof rawProfile.teamProject.teamId !== "string" || rawProfile.teamProject.teamId.length === 0) {
+          throw new Error(
+            `scopeProfiles.${profileId}.teamProject.teamId must be a non-empty string`
+          );
+        }
+        out.teamId = rawProfile.teamProject.teamId;
+      }
+      return out;
+    })();
+    if (rawProfile.autoPromote !== void 0 && rawProfile.autoPromote !== null && !isRecord(rawProfile.autoPromote)) {
+      throw new Error(`scopeProfiles.${profileId}.autoPromote must be an object`);
+    }
+    const rawAutoPromote = isRecord(rawProfile.autoPromote) ? rawProfile.autoPromote : {};
+    const hasAutoPromoteEnabled = Object.prototype.hasOwnProperty.call(
+      rawAutoPromote,
+      "enabled"
+    );
+    const autoPromoteEnabled = coerceBool(rawAutoPromote.enabled);
+    if (hasAutoPromoteEnabled && autoPromoteEnabled === void 0) {
+      throw new Error(
+        `scopeProfiles.${profileId}.autoPromote.enabled must be a boolean or boolean-like string`
+      );
+    }
+    const minConfidenceTier = (() => {
+      const rawTier = rawAutoPromote.minConfidenceTier;
+      if (rawTier === void 0 || rawTier === null) return "explicit";
+      if (typeof rawTier !== "string" || !CONFIDENCE_TIERS.includes(rawTier)) {
+        throw new Error(
+          `scopeProfiles.${profileId}.autoPromote.minConfidenceTier must be one of: ${CONFIDENCE_TIERS.join(", ")}`
+        );
+      }
+      return rawTier;
+    })();
+    const autoPromoteCategories = (() => {
+      if (rawAutoPromote.categories === void 0 || rawAutoPromote.categories === null) {
+        return ["fact", "correction", "decision", "preference"];
+      }
+      if (!Array.isArray(rawAutoPromote.categories)) {
+        throw new Error(
+          `scopeProfiles.${profileId}.autoPromote.categories must be an array`
+        );
+      }
+      const categories = [];
+      for (const entry of rawAutoPromote.categories) {
+        if (typeof entry !== "string" || !SCOPE_PROFILE_AUTO_PROMOTE_CATEGORIES.includes(entry)) {
+          throw new Error(
+            "scopeProfiles." + profileId + ".autoPromote.categories must contain only: " + SCOPE_PROFILE_AUTO_PROMOTE_CATEGORIES.join(", ")
+          );
+        }
+        categories.push(entry);
+      }
+      return categories;
+    })();
+    profiles[profileId] = {
+      readOrder,
+      writeDefault,
+      promotionTargets: parseScopeProfilePromotionTargets(
+        rawProfile.promotionTargets,
+        `scopeProfiles.${profileId}.promotionTargets`
+      ),
+      ...teamProject && Object.keys(teamProject).length > 0 ? { teamProject } : {},
+      autoPromote: {
+        enabled: autoPromoteEnabled === true,
+        targets: parseScopeProfilePromotionTargets(
+          rawAutoPromote.targets,
+          `scopeProfiles.${profileId}.autoPromote.targets`
+        ),
+        categories: autoPromoteCategories,
+        minConfidenceTier
+      }
+    };
+  }
+  return profiles;
+}
+function parseScopeTeams(value) {
+  if (value === void 0 || value === null) return {};
+  if (!isRecord(value)) {
+    throw new Error("teams must be an object");
+  }
+  const teams = {};
+  for (const [teamId, rawTeam] of Object.entries(value)) {
+    if (teamId.trim().length === 0) {
+      throw new Error("teams keys must not be empty");
+    }
+    if (!isRecord(rawTeam)) {
+      throw new Error(`teams.${teamId} must be an object`);
+    }
+    const projectNamespaceTemplate = rawTeam.projectNamespaceTemplate;
+    if (projectNamespaceTemplate !== void 0) {
+      if (typeof projectNamespaceTemplate !== "string" || projectNamespaceTemplate.length === 0) {
+        throw new Error(`teams.${teamId}.projectNamespaceTemplate must be a non-empty string`);
+      }
+    }
+    teams[teamId] = {
+      principals: parseStringList(rawTeam.principals, `teams.${teamId}.principals`),
+      ...projectNamespaceTemplate !== void 0 ? { projectNamespaceTemplate } : {},
+      read: parseStringList(rawTeam.read, `teams.${teamId}.read`),
+      write: parseStringList(rawTeam.write, `teams.${teamId}.write`),
+      promote: parseStringList(rawTeam.promote, `teams.${teamId}.promote`)
+    };
+  }
+  return teams;
+}
+function validateScopeProfileTeamReferences(profiles, teams) {
+  for (const [profileId, profile] of Object.entries(profiles)) {
+    const teamId = profile.teamProject?.teamId;
+    if (teamId && !Object.prototype.hasOwnProperty.call(teams, teamId)) {
+      throw new Error(
+        `scopeProfiles.${profileId}.teamProject.teamId references unknown team: ${teamId}`
+      );
+    }
+  }
+}
 function parseBoundedIntegerMs(value, fallback, min, max) {
   const coerced = coerceNumber(value);
   if (coerced === void 0) return fallback;
@@ -1088,6 +1310,21 @@ function parseConfig(raw) {
     globalFallback: codingGlobalFallbackRaw === void 0 ? true : codingGlobalFallbackRaw
   };
   const memoryDir = typeof cfg.memoryDir === "string" && cfg.memoryDir.length > 0 ? expandTildePath(cfg.memoryDir) : DEFAULT_MEMORY_DIR;
+  const scopeProfiles = parseScopeProfiles(cfg.scopeProfiles);
+  const teams = parseScopeTeams(cfg.teams);
+  validateScopeProfileTeamReferences(scopeProfiles, teams);
+  const defaultScopeProfile = (() => {
+    if (cfg.defaultScopeProfile === void 0 || cfg.defaultScopeProfile === null) {
+      return void 0;
+    }
+    if (typeof cfg.defaultScopeProfile !== "string" || cfg.defaultScopeProfile.trim().length === 0) {
+      throw new Error("defaultScopeProfile must be a non-empty string");
+    }
+    return cfg.defaultScopeProfile.trim();
+  })();
+  if (defaultScopeProfile !== void 0 && scopeProfiles[defaultScopeProfile] === void 0) {
+    throw new Error(`defaultScopeProfile references unknown scope profile: ${defaultScopeProfile}`);
+  }
   const rawIdentityInjectionMode = cfg.identityInjectionMode;
   const identityInjectionMode = rawIdentityInjectionMode && VALID_IDENTITY_INJECTION_MODES.includes(rawIdentityInjectionMode) ? rawIdentityInjectionMode : "recovery_only";
   const identityContinuityEnabled = cfg.identityContinuityEnabled === true;
@@ -2019,6 +2256,9 @@ function parseConfig(raw) {
       includeInRecallByDefault: p?.includeInRecallByDefault === true
     })).filter((p) => p.name.length > 0) : [],
     defaultRecallNamespaces: Array.isArray(cfg.defaultRecallNamespaces) ? ["self", "shared"].filter((x) => cfg.defaultRecallNamespaces.includes(x)) : ["self", "shared"],
+    scopeProfiles,
+    defaultScopeProfile,
+    teams,
     cronRecallMode: cfg.cronRecallMode === "none" ? "none" : cfg.cronRecallMode === "allowlist" ? "allowlist" : "all",
     cronRecallAllowlist: Array.isArray(cfg.cronRecallAllowlist) ? cfg.cronRecallAllowlist.filter((v) => typeof v === "string" && v.length > 0) : [],
     cronRecallPolicyEnabled: cfg.cronRecallPolicyEnabled !== false,
@@ -2929,4 +3169,4 @@ export {
   VALID_MEMORY_CATEGORIES,
   parseConfig
 };
-//# sourceMappingURL=chunk-KOI765XP.js.map
+//# sourceMappingURL=chunk-CTAV55JM.js.map