opkg 0.9.2 → 0.9.4

package/packages/cli/dist/chunk-N43IXOND.js

@@ -0,0 +1,732 @@
+#!/usr/bin/env node
+import {
+  findSubpathIndex,
+  normalizePathForProcessing,
+  parsePathWithPrefix
+} from "./chunk-YMKK4XPN.js";
+import {
+  DIR_PATTERNS,
+  FILE_PATTERNS
+} from "./chunk-IHVZ5AUJ.js";
+import {
+  exists
+} from "./chunk-S47F4OG4.js";
+import {
+  logger
+} from "./chunk-5EFWGD33.js";
+
+// ../core/src/core/platforms.ts
+import { join as join4 } from "path";
+
+// ../core/src/core/platform/platform-mapper.ts
+import { join, basename, dirname, extname, relative } from "path";
+import { realpathSync } from "fs";
+function extractPatternString(pattern) {
+  return typeof pattern == "string" ? pattern : pattern.pattern;
+}
+function extractFromPatternsFromFlow(flow) {
+  let from = flow.from;
+  if (typeof from == "string")
+    return [from];
+  if (Array.isArray(from))
+    return from.map((p) => extractPatternString(p));
+  if (typeof from == "object" && from !== null && "pattern" in from)
+    return [extractPatternString(from)];
+  if (typeof from == "object" && from !== null && "$switch" in from) {
+    let sw = from.$switch, patterns = [];
+    if (sw.cases)
+      for (let c of sw.cases) {
+        let v = c.value;
+        typeof v == "string" ? patterns.push(v) : typeof v == "object" && v !== null && "pattern" in v && patterns.push(v.pattern);
+      }
+    if (sw.default !== void 0) {
+      let d = sw.default;
+      typeof d == "string" ? patterns.push(d) : typeof d == "object" && d !== null && "pattern" in d && patterns.push(d.pattern);
+    }
+    return patterns;
+  }
+  return [];
+}
+function normalizePlatforms(platforms) {
+  if (!(!platforms || platforms.length === 0))
+    return platforms.map((p) => p.toLowerCase());
+}
+function extractToPatternsFromFlow(flow) {
+  let toField = flow.to, patterns = [];
+  if (typeof toField == "object" && toField !== null && "$switch" in toField) {
+    let switchExpr = toField;
+    if (switchExpr.$switch?.cases)
+      for (let caseItem of switchExpr.$switch.cases)
+        typeof caseItem.value == "string" ? patterns.push(caseItem.value) : typeof caseItem.value == "object" && "pattern" in caseItem.value && patterns.push(caseItem.value.pattern);
+    return switchExpr.$switch?.default && (typeof switchExpr.$switch.default == "string" ? patterns.push(switchExpr.$switch.default) : typeof switchExpr.$switch.default == "object" && "pattern" in switchExpr.$switch.default && patterns.push(switchExpr.$switch.default.pattern)), patterns;
+  }
+  return typeof toField == "string" ? [toField] : typeof toField == "object" && "pattern" in toField && typeof toField.pattern == "string" ? [toField.pattern] : typeof toField == "object" ? Object.keys(toField) : [];
+}
+function mapPlatformFileToUniversal(absPath, cwd = process.cwd()) {
+  let normalizedPath = normalizePathForProcessing(absPath);
+  for (let platform of getAllPlatforms({ includeDisabled: !0 }, cwd)) {
+    let definition = getPlatformDefinition(platform, cwd);
+    if (definition.export && definition.export.length > 0)
+      for (let flow of definition.export) {
+        let toPatterns = extractToPatternsFromFlow(flow);
+        for (let toPattern of toPatterns) {
+          if (!toPattern) continue;
+          let platformSubdirPath = toPattern.split("/").slice(0, -1).join("/"), subdirIndex = findSubpathIndex(normalizedPath, platformSubdirPath);
+          if (subdirIndex !== -1) {
+            if (typeof flow.from == "object" && "$switch" in flow.from)
+              continue;
+            let fromPatternRaw = Array.isArray(flow.from) ? flow.from[0] : flow.from, fromPattern = extractPatternString(fromPatternRaw), subdir = fromPattern.split("/")[0], absPattern = `/${platformSubdirPath}/`, relPattern = `${platformSubdirPath}/`, patternLength = normalizedPath.indexOf(absPattern) !== -1 ? absPattern.length : relPattern.length, relPathStart = subdirIndex + patternLength, relPath = normalizedPath.substring(relPathStart), workspaceExtMatch = relPath.match(/\.[^.]+$/), toExtMatch = toPattern.match(/\.[^./]+$/), fromExtMatch = fromPattern.match(/\.[^./]+$/);
+            if (workspaceExtMatch && toExtMatch && fromExtMatch) {
+              let workspaceExt = workspaceExtMatch[0], toExt = toExtMatch[0], fromExt = fromExtMatch[0];
+              workspaceExt === toExt && toExt !== fromExt && (relPath = relPath.slice(0, -workspaceExt.length) + fromExt);
+            }
+            return { platform, subdir, relPath };
+          }
+        }
+      }
+  }
+  return null;
+}
+function mapWorkspaceFileToUniversal(workspaceFilePath, cwd = process.cwd()) {
+  let absolutePath = realpathSync(workspaceFilePath), absoluteCwd = realpathSync(cwd), relativePath = relative(absoluteCwd, absolutePath).replace(/\\/g, "/");
+  for (let platform of getAllPlatforms({ includeDisabled: !0 }, cwd)) {
+    let definition = getPlatformDefinition(platform, cwd);
+    if (definition.import && definition.import.length > 0)
+      for (let flow of definition.import) {
+        let fromPatterns = extractFromPatternsFromFlow(flow);
+        if (fromPatterns.length === 0) continue;
+        let matchedFromPattern = null;
+        for (let p of fromPatterns)
+          if (matchesFlowPattern(relativePath, p)) {
+            matchedFromPattern = p;
+            break;
+          }
+        if (!matchedFromPattern) continue;
+        let toPattern;
+        if (typeof flow.to == "string")
+          toPattern = flow.to;
+        else if (typeof flow.to == "object" && flow.to !== null && "$switch" in flow.to) {
+          let d = flow.to.$switch.default;
+          toPattern = typeof d == "string" ? d : typeof d == "object" && d !== null && "pattern" in d ? d.pattern : void 0;
+        } else typeof flow.to == "object" && flow.to !== null && (toPattern = Object.keys(flow.to)[0]);
+        if (!toPattern) continue;
+        let subdir = toPattern.split("/")[0], relPath = mapPathUsingFlowPattern(relativePath, matchedFromPattern, toPattern);
+        if (relPath)
+          return { platform, subdir, relPath, flow };
+      }
+  }
+  return null;
+}
+function matchesFlowPattern(normalizedPath, pattern) {
+  let regexPattern = pattern.replace(/\./g, "\\.").replace(/\*\*\//g, "___DOUBLESTAR_SLASH___").replace(/\/\*\*/g, "___SLASH_DOUBLESTAR___").replace(/\*\*/g, "___DOUBLESTAR___").replace(/\*/g, "[^/]+").replace(/___DOUBLESTAR_SLASH___/g, "(?:.*?/)?").replace(/___SLASH_DOUBLESTAR___/g, "(?:/.*)?").replace(/___DOUBLESTAR___/g, ".*");
+  return new RegExp(`^${regexPattern}$`).test(normalizedPath);
+}
+function mapPathUsingFlowPattern(sourcePath, fromPattern, toPattern) {
+  if (fromPattern.includes("**") && toPattern.includes("**")) {
+    let fromParts = fromPattern.split("**"), toParts = toPattern.split("**"), fromBase = fromParts[0].replace(/\/$/, ""), toBase = toParts[0].replace(/\/$/, ""), fromSuffix = fromParts[1] || "", toSuffix = toParts[1] || "", relativeSubpath = sourcePath;
+    if (fromBase) {
+      if (!sourcePath.startsWith(fromBase + "/") && !sourcePath.startsWith("/" + fromBase + "/"))
+        return null;
+      let startPos = sourcePath.indexOf(fromBase);
+      relativeSubpath = sourcePath.slice(startPos + fromBase.length + 1);
+    }
+    if (fromSuffix && toSuffix) {
+      let fromExt = fromSuffix.replace(/^\/?\*+/, ""), toExt = toSuffix.replace(/^\/?\*+/, "");
+      fromExt && toExt && fromExt !== toExt && (relativeSubpath = relativeSubpath.replace(new RegExp(fromExt.replace(".", "\\.") + "$"), toExt));
+    }
+    return relativeSubpath;
+  }
+  if (fromPattern.includes("*") && toPattern.includes("*")) {
+    let sourceFileName = basename(sourcePath), sourceExt2 = extname(sourcePath), sourceBase = basename(sourcePath, sourceExt2), toParts = toPattern.split("*"), toPrefix = toParts[0], toSuffix = toParts[1] || "", targetExt2 = toSuffix.startsWith(".") ? toSuffix : sourceExt2 + toSuffix, targetFileName = sourceBase + targetExt2;
+    return toPrefix.split("/").filter((p) => p).slice(1).concat([targetFileName]).join("/");
+  }
+  let fileName = basename(sourcePath), toFileName = basename(toPattern), sourceExt = extname(fileName), targetExt = extname(toFileName), mappedFileName = fileName;
+  sourceExt !== targetExt && targetExt && (mappedFileName = basename(fileName, sourceExt) + targetExt);
+  let relDir = dirname(toPattern).split("/").filter((p) => p && p !== ".").slice(1).join("/");
+  return relDir ? `${relDir}/${mappedFileName}` : mappedFileName;
+}
+
+// ../core/src/core/platform/platform-file.ts
+function parseUniversalPath(path2, options = {}) {
+  let universalSubdirs = getPlatformsState(options.cwd ?? null).universalSubdirs, knownPlatforms = getAllPlatforms({ includeDisabled: !0 }), withoutPrefix = normalizePathForProcessing(path2);
+  for (let subdir of universalSubdirs) {
+    let parsed = parsePathWithPrefix(withoutPrefix, subdir);
+    if (parsed) {
+      let remainingPath = parsed.remaining, platformSuffix, normalizedRelPath = remainingPath;
+      if (options.allowPlatformSuffix !== !1) {
+        let segments = remainingPath.split("/");
+        for (let i = 0; i < segments.length - 1; i++) {
+          let segment = segments[i];
+          for (let platform of knownPlatforms)
+            if (segment.endsWith(`.${platform}`) && isPlatformId(platform)) {
+              platformSuffix = platform, segments[i] = segment.slice(0, -platform.length - 1), normalizedRelPath = segments.join("/");
+              break;
+            }
+          if (platformSuffix) break;
+        }
+        if (!platformSuffix) {
+          let parts = remainingPath.split(".");
+          if (parts.length >= 3 && parts[parts.length - 1] === "md") {
+            let possiblePlatformSuffix = parts[parts.length - 2];
+            isPlatformId(possiblePlatformSuffix) && (platformSuffix = possiblePlatformSuffix, normalizedRelPath = parts.slice(0, -2).join(".") + FILE_PATTERNS.MD_FILES);
+          }
+        }
+      }
+      return {
+        universalSubdir: subdir,
+        relPath: normalizedRelPath,
+        platformSuffix
+      };
+    }
+  }
+  return null;
+}
+
+// ../core/src/utils/jsonc.ts
+import { readFileSync, existsSync } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+import { fileURLToPath } from "url";
+import { parse } from "jsonc-parser";
+function getProjectRoot() {
+  let __filename = fileURLToPath(import.meta.url), dir = dirname2(__filename);
+  for (let i = 0; i < 10; i++) {
+    if (existsSync(join2(dir, "platforms.jsonc")))
+      return dir;
+    let parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  let fallback = dirname2(__filename);
+  return join2(fallback, "..", "..");
+}
+function readJsoncFileSync(relativePath) {
+  let projectRoot = getProjectRoot(), fullPath = join2(projectRoot, relativePath);
+  try {
+    let content = readFileSync(fullPath, "utf-8"), parsed = parse(content);
+    if (parsed === void 0)
+      throw new Error(`Failed to parse JSONC file: ${relativePath}`);
+    return parsed;
+  } catch (error) {
+    throw logger.error(`Failed to read JSONC file: ${relativePath}`, { error, fullPath }), new Error(`Failed to read JSONC file ${relativePath}: ${error}`);
+  }
+}
+function readJsoncOrJson(fullPath) {
+  if (existsSync(fullPath))
+    try {
+      let content = readFileSync(fullPath, "utf-8"), parsed = parse(content);
+      if (parsed && typeof parsed == "object" && !Array.isArray(parsed) && parsed !== null)
+        return parsed;
+    } catch (error) {
+      logger.warn(`Failed to parse JSONC/JSON file ${fullPath}: ${error.message}`);
+    }
+}
+
+// ../core/src/core/platforms.ts
+import * as os2 from "os";
+
+// ../core/src/core/flows/switch-resolver.ts
+import { minimatch as minimatch2 } from "minimatch";
+
+// ../core/src/utils/path-comparison.ts
+import * as path from "path";
+import * as os from "os";
+import { minimatch } from "minimatch";
+function isPathLike(value) {
+  return typeof value != "string" ? !1 : value.includes("/") || // Unix-style path
+  value.includes("\\") || // Windows-style path
+  value.startsWith("~") || // Home directory reference
+  value.match(/^[A-Za-z]:/) !== null;
+}
+function expandTilde(filepath) {
+  return filepath && (filepath === "~" ? os.homedir() : filepath.startsWith("~/") ? path.join(os.homedir(), filepath.slice(2)) : filepath);
+}
+function hasGlobChars(pattern) {
+  return /[*?[\]{}]/.test(pattern);
+}
+function comparePathsWithGlobSupport(value, pattern) {
+  let expandedValue = expandTilde(value), expandedPattern = expandTilde(pattern), normalizedValue = path.normalize(expandedValue), normalizedPattern = path.normalize(expandedPattern);
+  return hasGlobChars(normalizedPattern) ? minimatch(normalizedValue, normalizedPattern, {
+    dot: !0,
+    // Match dotfiles
+    nocase: process.platform === "win32"
+    // Case-insensitive on Windows
+  }) : process.platform === "win32" ? normalizedValue.toLowerCase() === normalizedPattern.toLowerCase() : normalizedValue === normalizedPattern;
+}
+function smartEquals(left, right) {
+  if (isPathLike(left) || isPathLike(right)) {
+    let leftStr = String(left), rightStr = String(right);
+    return comparePathsWithGlobSupport(leftStr, rightStr);
+  }
+  return left === right;
+}
+function smartNotEquals(left, right) {
+  return !smartEquals(left, right);
+}
+
+// ../core/src/core/flows/switch-resolver.ts
+function extractPattern(value) {
+  return typeof value == "string" ? value : value.pattern;
+}
+function extractSchema(value) {
+  if (typeof value != "string")
+    return value.schema;
+}
+function resolveSwitchExpression(switchExpr, context) {
+  return resolveSwitchExpressionFull(switchExpr, context).pattern;
+}
+function resolveSwitchExpressionFull(switchExpr, context) {
+  let { field, cases, default: defaultValue } = switchExpr.$switch, fieldValue = resolveFieldValue(field, context);
+  for (let switchCase of cases)
+    if (matchesPattern(fieldValue, switchCase.pattern))
+      return {
+        pattern: extractPattern(switchCase.value),
+        schema: extractSchema(switchCase.value)
+      };
+  if (defaultValue !== void 0)
+    return {
+      pattern: extractPattern(defaultValue),
+      schema: extractSchema(defaultValue)
+    };
+  throw new Error(
+    `No matching case in $switch expression for ${field}=${JSON.stringify(fieldValue)}, and no default provided`
+  );
+}
+function resolveFieldValue(field, context) {
+  if (field.startsWith("$$")) {
+    let varName = field.slice(2);
+    if (!(varName in context.variables))
+      throw new Error(`Variable '${varName}' not found in flow context`);
+    return context.variables[varName];
+  }
+  return field;
+}
+function matchesPattern(value, pattern) {
+  return typeof pattern == "object" && pattern !== null ? deepEquals(value, pattern) : typeof pattern == "string" ? pattern.includes("*") || pattern.includes("?") || pattern.includes("[") ? minimatch2(String(value), pattern) : smartEquals(value, pattern) : value === pattern;
+}
+function deepEquals(a, b) {
+  if (a === b) return !0;
+  if (typeof a != typeof b) return !1;
+  if (a === null || b === null || typeof a != "object") return a === b;
+  if (Array.isArray(a) !== Array.isArray(b)) return !1;
+  if (Array.isArray(a))
+    return a.length !== b.length ? !1 : a.every((item, index) => deepEquals(item, b[index]));
+  let keysA = Object.keys(a), keysB = Object.keys(b);
+  return keysA.length !== keysB.length ? !1 : keysA.every((key) => keysB.includes(key) && deepEquals(a[key], b[key]));
+}
+function validateSwitchExpression(switchExpr) {
+  let errors = [];
+  if (!switchExpr.$switch)
+    return errors.push("Switch expression must have $switch property"), { valid: !1, errors };
+  let { field, cases, default: defaultValue } = switchExpr.$switch;
+  return field ? typeof field != "string" && errors.push("Switch expression field must be a string") : errors.push("Switch expression missing required field: field"), cases ? Array.isArray(cases) ? cases.length === 0 ? errors.push("Switch expression must have at least one case") : cases.forEach((switchCase, index) => {
+    if (!switchCase || typeof switchCase != "object") {
+      errors.push(`Case at index ${index} must be an object`);
+      return;
+    }
+    "pattern" in switchCase || errors.push(`Case at index ${index} missing required field: pattern`), "value" in switchCase ? isValidSwitchCaseValue(switchCase.value) || errors.push(`Case at index ${index} value must be a string or object with 'pattern' field`) : errors.push(`Case at index ${index} missing required field: value`);
+  }) : errors.push("Switch expression cases must be an array") : errors.push("Switch expression missing required field: cases"), defaultValue !== void 0 && !isValidSwitchCaseValue(defaultValue) && errors.push("Switch expression default must be a string or object with 'pattern' field"), {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function isValidSwitchCaseValue(value) {
+  return typeof value == "string" ? !0 : typeof value == "object" && value !== null && "pattern" in value ? typeof value.pattern == "string" : !1;
+}
+
+// ../core/src/core/universal-patterns.ts
+import { minimatch as minimatch3 } from "minimatch";
+function isPatternMatch(filePath, pattern) {
+  let normalizedPath = normalizePathForProcessing(filePath), normalizedPattern = normalizePathForProcessing(pattern);
+  return minimatch3(normalizedPath, normalizedPattern, {
+    dot: !1,
+    // Don't match dotfiles by default
+    nocase: !1,
+    // Case-sensitive matching
+    matchBase: !1
+    // Don't match basename only
+  });
+}
+function matchesAnyPattern(filePath, patterns) {
+  let normalized = normalizePathForProcessing(filePath);
+  for (let pattern of patterns)
+    if (isPatternMatch(normalized, pattern))
+      return !0;
+  return !1;
+}
+function extractFirstComponent(pathOrPattern) {
+  let normalized = normalizePathForProcessing(pathOrPattern);
+  return normalized && normalized.split("/")[0] || null;
+}
+function isSubdirectoryPattern(pattern) {
+  let firstComponent = extractFirstComponent(pattern);
+  return firstComponent !== null && !firstComponent.includes(".");
+}
+function extractSubdirectoriesFromPatterns(patterns) {
+  let subdirs = /* @__PURE__ */ new Set();
+  for (let pattern of patterns)
+    if (isSubdirectoryPattern(pattern)) {
+      let firstComponent = extractFirstComponent(pattern);
+      firstComponent && subdirs.add(firstComponent);
+    }
+  return subdirs;
+}
+
+// ../core/src/core/platforms.ts
+function isGlobalFlowsConfig(cfg) {
+  return ("export" in cfg || "import" in cfg) && !("name" in cfg) && !("rootDir" in cfg);
+}
+function createPlatformDefinitions(config) {
+  let result = {};
+  for (let [id, cfg] of Object.entries(config)) {
+    if (id === "$schema" || id === "global" || isGlobalFlowsConfig(cfg)) continue;
+    let platformConfig = cfg, platformId = id;
+    result[platformId] = {
+      id: platformId,
+      name: platformConfig.name,
+      rootDir: platformConfig.rootDir,
+      rootFile: platformConfig.rootFile,
+      detection: platformConfig.detection,
+      export: platformConfig.export || [],
+      import: platformConfig.import || [],
+      aliases: platformConfig.aliases,
+      enabled: platformConfig.enabled !== !1,
+      description: platformConfig.description,
+      variables: platformConfig.variables
+    };
+  }
+  return result;
+}
+var BUILT_IN_CONFIG = readJsoncFileSync("platforms.jsonc"), builtinErrors = validatePlatformsConfig(BUILT_IN_CONFIG);
+if (builtinErrors.length > 0)
+  throw new Error(`Built-in platforms.jsonc validation failed:
+  - ${builtinErrors.join(`
+  - `)}`);
+function mergePlatformsConfig(base, override) {
+  let merged = { ...base };
+  for (let [platformId, overridePlat] of Object.entries(override)) {
+    if (platformId === "$schema") {
+      merged[platformId] = overridePlat;
+      continue;
+    }
+    let basePlat = base[platformId];
+    if (!basePlat) {
+      merged[platformId] = overridePlat;
+      continue;
+    }
+    if (platformId === "global") {
+      isGlobalFlowsConfig(overridePlat) && (merged[platformId] = overridePlat);
+      continue;
+    }
+    if (isGlobalFlowsConfig(overridePlat) || isGlobalFlowsConfig(basePlat)) {
+      merged[platformId] = overridePlat;
+      continue;
+    }
+    let overrideCfg = overridePlat, baseCfg = basePlat;
+    merged[platformId] = {
+      name: overrideCfg.name ?? baseCfg.name,
+      rootDir: overrideCfg.rootDir ?? baseCfg.rootDir,
+      rootFile: overrideCfg.rootFile ?? baseCfg.rootFile,
+      detection: overrideCfg.detection ?? baseCfg.detection,
+      // replace array
+      aliases: overrideCfg.aliases ?? baseCfg.aliases,
+      // replace array
+      enabled: overrideCfg.enabled ?? baseCfg.enabled,
+      description: overrideCfg.description ?? baseCfg.description,
+      variables: overrideCfg.variables ?? baseCfg.variables,
+      export: overrideCfg.export ?? baseCfg.export,
+      // replace array (no merge)
+      import: overrideCfg.import ?? baseCfg.import
+      // replace array (no merge)
+    };
+  }
+  return merged;
+}
+function validatePlatformsConfig(config) {
+  let errors = [];
+  for (let [platformId, platConfig] of Object.entries(config)) {
+    if (platformId === "$schema")
+      continue;
+    if (platformId === "global") {
+      isGlobalFlowsConfig(platConfig) && errors.push(...validateGlobalFlowsConfig(platConfig));
+      continue;
+    }
+    if (isGlobalFlowsConfig(platConfig)) {
+      errors.push(`Platform '${platformId}': Cannot use global flows config format for platform entry`);
+      continue;
+    }
+    let cfg = platConfig;
+    !cfg.detection && (!cfg.rootDir || cfg.rootDir.trim() === "") && errors.push(`Platform '${platformId}': Must define either 'detection' array or 'rootDir'`), (!cfg.name || cfg.name.trim() === "") && errors.push(`Platform '${platformId}': Missing or empty name`), cfg.export !== void 0 && (Array.isArray(cfg.export) ? errors.push(...validateFlows(cfg.export, `${platformId}.export`)) : errors.push(`Platform '${platformId}': export must be array or undefined`)), cfg.import !== void 0 && (Array.isArray(cfg.import) ? errors.push(...validateFlows(cfg.import, `${platformId}.import`)) : errors.push(`Platform '${platformId}': import must be array or undefined`));
+    let hasExport = cfg.export && cfg.export.length > 0, hasImport = cfg.import && cfg.import.length > 0, hasDetection = cfg.detection && cfg.detection.length > 0;
+    !hasExport && !hasImport && !cfg.rootFile && !hasDetection && errors.push(`Platform '${platformId}': Must define at least one of 'export', 'import', 'detection', or 'rootFile'`), cfg.aliases !== void 0 && (!Array.isArray(cfg.aliases) || cfg.aliases.some((a) => typeof a != "string")) && errors.push(`Platform '${platformId}': aliases must be array of strings or undefined`), typeof cfg.enabled != "boolean" && cfg.enabled !== void 0 && errors.push(`Platform '${platformId}': enabled must be boolean or undefined`), cfg.variables !== void 0 && (typeof cfg.variables != "object" || Array.isArray(cfg.variables)) && errors.push(`Platform '${platformId}': variables must be object or undefined`);
+  }
+  return errors;
+}
+function extractPatternString2(field) {
+  if (typeof field == "string")
+    return field;
+  if (typeof field == "object" && field !== null) {
+    if ("pattern" in field)
+      return field.pattern;
+    if ("$switch" in field)
+      return null;
+  }
+  return Array.isArray(field) && field.length > 0 ? extractPatternString2(field[0]) : null;
+}
+function validateGlobalFlowsConfig(config) {
+  let errors = [];
+  return config.export !== void 0 && (Array.isArray(config.export) ? errors.push(...validateFlows(config.export, "global.export")) : errors.push("Global config: export must be array or undefined")), config.import !== void 0 && (Array.isArray(config.import) ? errors.push(...validateFlows(config.import, "global.import")) : errors.push("Global config: import must be array or undefined")), config.description !== void 0 && typeof config.description != "string" && errors.push("Global config: description must be string or undefined"), errors;
+}
+function isSwitchExpression(value) {
+  return typeof value == "object" && value !== null && "$switch" in value;
+}
+function isPatternObject(value) {
+  return typeof value == "object" && value !== null && "pattern" in value && typeof value.pattern == "string";
+}
+function validatePatternObject(value, context) {
+  let errors = [];
+  return (typeof value.pattern != "string" || value.pattern.trim() === "") && errors.push(`${context}: pattern must be non-empty string`), "schema" in value && typeof value.schema != "string" && errors.push(`${context}: schema must be string if provided`), errors;
+}
+function validateFlows(flows, context) {
+  let errors = [];
+  for (let i = 0; i < flows.length; i++) {
+    let flow = flows[i];
+    if (flow.from ? typeof flow.from == "string" ? flow.from.trim() === "" && errors.push(`${context}, flows[${i}]: 'from' cannot be empty`) : Array.isArray(flow.from) ? (flow.from.length === 0 && errors.push(`${context}, flows[${i}]: 'from' array cannot be empty`), flow.from.forEach((p, j) => {
+      typeof p == "string" ? p.trim() === "" && errors.push(`${context}, flows[${i}]: 'from' array item ${j} cannot be empty string`) : isPatternObject(p) ? errors.push(...validatePatternObject(p, `${context}, flows[${i}].from[${j}]`)) : errors.push(`${context}, flows[${i}]: 'from' array item ${j} must be string or pattern object`);
+    })) : isSwitchExpression(flow.from) || (isPatternObject(flow.from) ? errors.push(...validatePatternObject(flow.from, `${context}, flows[${i}].from`)) : errors.push(`${context}, flows[${i}]: 'from' must be string, array, pattern object, or $switch expression`)) : errors.push(`${context}, flows[${i}]: Missing 'from' field`), !flow.to)
+      errors.push(`${context}, flows[${i}]: Missing 'to' field`);
+    else if (typeof flow.to == "string")
+      flow.to.trim() === "" && errors.push(`${context}, flows[${i}]: 'to' cannot be empty`);
+    else if (isSwitchExpression(flow.to)) {
+      let switchValidation = validateSwitchExpression(flow.to);
+      switchValidation.valid || switchValidation.errors.forEach((err) => {
+        errors.push(`${context}, flows[${i}]: ${err}`);
+      });
+    } else if (isPatternObject(flow.to))
+      errors.push(...validatePatternObject(flow.to, `${context}, flows[${i}].to`));
+    else if (typeof flow.to == "object")
+      for (let [targetPath, targetFlow] of Object.entries(flow.to))
+        (typeof targetPath != "string" || targetPath.trim() === "") && errors.push(`${context}, flows[${i}].to: target path cannot be empty`);
+    else
+      errors.push(`${context}, flows[${i}]: 'to' must be string, pattern object, switch expression, or multi-target object`);
+    if (flow.merge !== void 0) {
+      let validMerges = ["replace", "shallow", "deep", "composite"];
+      validMerges.includes(flow.merge) || errors.push(`${context}, flows[${i}]: Invalid merge strategy '${flow.merge}'. Must be one of: ${validMerges.join(", ")}`);
+    }
+    let pipe = flow.pipe;
+    pipe !== void 0 && (Array.isArray(pipe) ? pipe.some((p) => typeof p != "string" || p.trim() === "") && errors.push(`${context}, flows[${i}]: 'pipe' must be array of strings`) : errors.push(`${context}, flows[${i}]: 'pipe' must be array`)), flow.map !== void 0 && !Array.isArray(flow.map) && errors.push(`${context}, flows[${i}]: 'map' must be array of operations`), flow.pick !== void 0 && !Array.isArray(flow.pick) && errors.push(`${context}, flows[${i}]: 'pick' must be array or undefined`), flow.omit !== void 0 && !Array.isArray(flow.omit) && errors.push(`${context}, flows[${i}]: 'omit' must be array or undefined`), flow.embed !== void 0 && (typeof flow.embed != "string" || flow.embed.trim() === "") && errors.push(`${context}, flows[${i}]: 'embed' must be non-empty string or undefined`);
+  }
+  return errors;
+}
+var GLOBAL_DIR = join4(os2.homedir(), ".openpackage"), stateCache = /* @__PURE__ */ new Map();
+function getPlatformsState(targetDir) {
+  let key = targetDir ?? null;
+  if (stateCache.has(key))
+    return stateCache.get(key);
+  let config;
+  if (key === null) {
+    let globalFile = readJsoncOrJson(join4(GLOBAL_DIR, "platforms.jsonc")) ?? readJsoncOrJson(join4(GLOBAL_DIR, "platforms.json"));
+    config = globalFile ? mergePlatformsConfig(BUILT_IN_CONFIG, globalFile) : BUILT_IN_CONFIG;
+    let errors = validatePlatformsConfig(config);
+    if (errors.length > 0)
+      throw new Error(`Global platforms config validation failed:
+  - ${errors.join(`
+  - `)}`);
+  } else {
+    let globalConfig2 = getPlatformsState(null).config, localDir = join4(key, DIR_PATTERNS.OPENPACKAGE), localFile = readJsoncOrJson(join4(localDir, "platforms.jsonc")) ?? readJsoncOrJson(join4(localDir, "platforms.json"));
+    config = localFile ? mergePlatformsConfig(globalConfig2, localFile) : globalConfig2;
+    let errors = validatePlatformsConfig(config);
+    if (errors.length > 0)
+      throw new Error(`Local platforms config validation failed in ${key}:
+  - ${errors.join(`
+  - `)}`);
+  }
+  let globalConfig = config.global, globalExportFlows = globalConfig && isGlobalFlowsConfig(globalConfig) ? globalConfig.export : void 0, globalImportFlows = globalConfig && isGlobalFlowsConfig(globalConfig) ? globalConfig.import : void 0, defs = createPlatformDefinitions(config), dirLookup = {}, aliasLookup = {}, universalPatterns = /* @__PURE__ */ new Set(), rootFiles = [], allPlatforms = [];
+  for (let def of Object.values(defs)) {
+    allPlatforms.push(def.id), def.rootDir && (dirLookup[def.rootDir] = def.id);
+    for (let alias of def.aliases ?? [])
+      aliasLookup[alias.toLowerCase()] = def.id;
+    if (def.export && def.export.length > 0)
+      for (let flow of def.export) {
+        let pattern = extractPatternString2(flow.from);
+        pattern && universalPatterns.add(pattern);
+      }
+    def.rootFile && rootFiles.push(def.rootFile);
+  }
+  if (globalExportFlows && globalExportFlows.length > 0)
+    for (let flow of globalExportFlows) {
+      let pattern = extractPatternString2(flow.from);
+      pattern && universalPatterns.add(pattern);
+    }
+  let universalSubdirs = extractSubdirectoriesFromPatterns(universalPatterns), enabledPlatforms = allPlatforms.filter((p) => defs[p].enabled), state = {
+    config,
+    globalExportFlows,
+    globalImportFlows,
+    defs,
+    dirLookup,
+    aliasLookup,
+    universalPatterns,
+    universalSubdirs,
+    rootFiles,
+    allPlatforms,
+    enabledPlatforms
+  };
+  return stateCache.set(key, state), state;
+}
+function getPlatformDefinitions(targetDir) {
+  return getPlatformsState(targetDir).defs;
+}
+function getGlobalExportFlows(targetDir) {
+  return getPlatformsState(targetDir).globalExportFlows;
+}
+function getGlobalImportFlows(targetDir) {
+  return getPlatformsState(targetDir).globalImportFlows;
+}
+function platformUsesFlows(platform, targetDir) {
+  try {
+    let def = getPlatformDefinition(platform, targetDir), hasExport = def.export !== void 0 && def.export.length > 0, hasImport = def.import !== void 0 && def.import.length > 0;
+    return hasExport || hasImport;
+  } catch {
+    return !1;
+  }
+}
+function getAllUniversalPatterns(targetDir) {
+  return new Set(getPlatformsState(targetDir).universalPatterns);
+}
+function matchesUniversalPattern(filePath, targetDir) {
+  let patterns = getAllUniversalPatterns(targetDir);
+  return matchesAnyPattern(filePath, patterns);
+}
+function getPlatformDirLookup(targetDir) {
+  return getPlatformsState(targetDir).dirLookup;
+}
+function getPlatformRootFiles(targetDir) {
+  return getPlatformsState(targetDir).rootFiles;
+}
+function getPlatformDefinition(name, targetDir) {
+  let def = getPlatformsState(targetDir).defs[name];
+  if (!def)
+    throw new Error(`Unknown platform: ${name}`);
+  return def;
+}
+function deriveRootDirFromFlows(definition) {
+  if (definition.rootDir)
+    return definition.rootDir;
+  let extractPathFromSwitch = (switchExpr) => isSwitchExpression(switchExpr) ? switchExpr.$switch.default || switchExpr.$switch.cases[0]?.value : null;
+  if (definition.export && definition.export.length > 0)
+    for (let flow of definition.export) {
+      let toPattern = null;
+      if (typeof flow.to == "string" ? toPattern = flow.to : isSwitchExpression(flow.to) ? toPattern = extractPathFromSwitch(flow.to) : toPattern = Object.keys(flow.to)[0], toPattern) {
+        let match = toPattern.match(/^(\.[^/]+)/);
+        if (match)
+          return match[1];
+      }
+    }
+  if (definition.import && definition.import.length > 0)
+    for (let flow of definition.import) {
+      let fromPattern = null;
+      if (typeof flow.from == "string" ? fromPattern = flow.from : Array.isArray(flow.from) ? fromPattern = flow.from[0] : isSwitchExpression(flow.from) && (fromPattern = extractPathFromSwitch(flow.from)), fromPattern) {
+        let match = fromPattern.match(/^(\.[^/]+)/);
+        if (match)
+          return match[1];
+      }
+    }
+  return `.${definition.id}`;
+}
+function getAllPlatforms(options, targetDir) {
+  let state = getPlatformsState(targetDir);
+  return options?.includeDisabled ? state.allPlatforms : state.enabledPlatforms;
+}
+function resolvePlatformName(input, targetDir) {
+  if (!input)
+    return;
+  let state = getPlatformsState(targetDir), normalized = input.toLowerCase();
+  return normalized in state.defs ? normalized : state.aliasLookup[normalized];
+}
+function resolvePlatformKey(key, targetDir) {
+  if (!key) return null;
+  let normalized = key.toLowerCase(), state = getPlatformsState(targetDir);
+  return normalized in state.defs ? normalized : state.aliasLookup[normalized] ?? null;
+}
+async function detectAllPlatforms(targetDir) {
+  let state = getPlatformsState(targetDir), detectionPromises = state.enabledPlatforms.map(
+    async (platform) => {
+      let definition = state.defs[platform];
+      if (definition.detection && definition.detection.length > 0) {
+        for (let pattern of definition.detection) {
+          let testPath = join4(targetDir, pattern);
+          if (await exists(testPath))
+            return {
+              name: platform,
+              detected: !0
+            };
+        }
+        return {
+          name: platform,
+          detected: !1
+        };
+      }
+      let detected = !1;
+      if (definition.rootDir) {
+        let rootDirPath = join4(targetDir, definition.rootDir);
+        detected = await exists(rootDirPath);
+      }
+      if (!detected && definition.rootFile && definition.rootFile !== FILE_PATTERNS.AGENTS_MD) {
+        let rootFilePath = join4(targetDir, definition.rootFile);
+        detected = await exists(rootFilePath);
+      }
+      return {
+        name: platform,
+        detected
+      };
+    }
+  );
+  return await Promise.all(detectionPromises);
+}
+async function getDetectedPlatforms2(cwd) {
+  return (await detectAllPlatforms(cwd)).filter((result) => result.detected).map((result) => result.name);
+}
+function isPlatformId(value, targetDir) {
+  return value ? value in getPlatformsState(targetDir).defs : !1;
+}
+function inferPlatformFromWorkspaceFile(fullPath, sourceDir, registryPath, targetDir) {
+  let mapping = mapPlatformFileToUniversal(fullPath, targetDir);
+  if (mapping?.platform)
+    return mapping.platform;
+  let fromSource = getPlatformDirLookup(targetDir)[sourceDir];
+  if (fromSource)
+    return fromSource;
+  let state = getPlatformsState(targetDir);
+  for (let [platformId, def] of Object.entries(state.defs))
+    if (deriveRootDirFromFlows(def) === sourceDir)
+      return platformId;
+  let parsed = parseUniversalPath(registryPath, { allowPlatformSuffix: !0 });
+  if (parsed?.platformSuffix && isPlatformId(parsed.platformSuffix, targetDir))
+    return parsed.platformSuffix;
+}
+
+export {
+  parseUniversalPath,
+  smartEquals,
+  smartNotEquals,
+  resolveSwitchExpression,
+  resolveSwitchExpressionFull,
+  validateSwitchExpression,
+  getPlatformsState,
+  getPlatformDefinitions,
+  getGlobalExportFlows,
+  getGlobalImportFlows,
+  platformUsesFlows,
+  matchesUniversalPattern,
+  getPlatformRootFiles,
+  getPlatformDefinition,
+  deriveRootDirFromFlows,
+  getAllPlatforms,
+  resolvePlatformName,
+  resolvePlatformKey,
+  getDetectedPlatforms2 as getDetectedPlatforms,
+  isPlatformId,
+  inferPlatformFromWorkspaceFile,
+  normalizePlatforms,
+  mapWorkspaceFileToUniversal
+};
+//# sourceMappingURL=chunk-N43IXOND.js.map