@fleox-agent-crm/agentcrm 0.0.0-stage → 0.3.0

package/dist/agent/chunks/memory-WNR3VHUJ.mjs

@@ -0,0 +1,56 @@
+import { createRequire as __acrmRequire } from "node:module";
+import { fileURLToPath as __acrmPath } from "node:url";
+import { dirname as __acrmDirname } from "node:path";
+const require2 = __acrmRequire(import.meta.url);
+const __filename = __acrmPath(import.meta.url);
+const __dirname = __acrmDirname(__filename);
+import { c as createStoreCore, s as snapshotFromDocs } from "./core-Dy7vY9H6.mjs";
+import { w as withFileStore } from "./index-RCmo-uld.mjs";
+import { a as assertFileId } from "./ids-u-noYcy5.mjs";
+import "./types-BOy9PUl7.mjs";
+function createMemoryFileStore(initial) {
+  const blobs = initial ?? /* @__PURE__ */ new Map();
+  return {
+    kind: "memory",
+    blobs,
+    async put(id, bytes) {
+      assertFileId(id);
+      blobs.set(id, new Uint8Array(bytes));
+    },
+    async putMany(items) {
+      for (const it of items) {
+        assertFileId(it.id);
+        blobs.set(it.id, new Uint8Array(it.bytes));
+      }
+    },
+    async get(id) {
+      const b = blobs.get(id);
+      return b ? new Uint8Array(b) : null;
+    },
+    async delete(id) {
+      blobs.delete(id);
+    },
+    async list() {
+      return [...blobs.keys()].sort();
+    }
+  };
+}
+function createMemoryStore(opts = {}) {
+  const store = createStoreCore({
+    kind: "memory",
+    async load() {
+      return snapshotFromDocs(opts.initial ?? {});
+    },
+    async persist() {
+      const err = opts.failNextWrite?.();
+      if (err) throw err;
+    },
+    async identity() {
+      return opts.identity === void 0 ? { uid: "local", email: "admin@localhost", displayName: "Admin", role: "admin" } : opts.identity;
+    }
+  });
+  return withFileStore(store, createMemoryFileStore(opts.blobs));
+}
+export {
+  createMemoryStore
+};

package/dist/agent/chunks/migrate-CsClnnN8.mjs

@@ -0,0 +1,182 @@
+import { createRequire as __acrmRequire } from "node:module";
+import { fileURLToPath as __acrmPath } from "node:url";
+import { dirname as __acrmDirname } from "node:path";
+const require2 = __acrmRequire(import.meta.url);
+const __filename = __acrmPath(import.meta.url);
+const __dirname = __acrmDirname(__filename);
+import { a as standardObjects, S as STANDARD_IMAGE_FIELDS } from "./standardObjects-CheqfDqa.mjs";
+import { assertCan } from "./context-CxFfqS4D.mjs";
+import { settingsDoc, objectOf } from "./store-5gqRSKXg.mjs";
+const FR = {
+  objects: {
+    companies: { singular: "Entreprise", plural: "Entreprises" },
+    people: { singular: "Contact", plural: "Contacts" },
+    deals: { singular: "Affaire", plural: "Affaires" }
+  },
+  fields: {
+    "companies.name": "Nom",
+    "companies.domain": "Domaine",
+    "companies.industry": "Secteur",
+    "companies.employees": "Effectif",
+    "companies.annualRevenue": "Chiffre d'affaires annuel",
+    "companies.address": "Adresse",
+    "companies.linkedin": "LinkedIn",
+    "companies.phone": "Téléphone",
+    "companies.tags": "Étiquettes",
+    "companies.logo": "Logo",
+    "people.firstName": "Prénom",
+    "people.lastName": "Nom de famille",
+    "people.name": "Nom",
+    "people.email": "E-mail",
+    "people.phone": "Téléphone",
+    "people.jobTitle": "Fonction",
+    "people.company": "Entreprise",
+    "people.city": "Ville",
+    "people.linkedin": "LinkedIn",
+    "people.lifecycleStage": "Cycle de vie",
+    "people.leadSource": "Source du lead",
+    "people.tags": "Étiquettes",
+    "people.avatar": "Photo",
+    "deals.name": "Nom",
+    "deals.amount": "Montant",
+    "deals.stage": "Étape",
+    "deals.pipeline": "Pipeline",
+    "deals.closeDate": "Date de clôture",
+    "deals.probability": "Probabilité",
+    "deals.company": "Entreprise",
+    "deals.contacts": "Contacts",
+    "deals.lostReason": "Motif de perte"
+  },
+  options: {
+    "companies.industry.software": "Logiciel",
+    "companies.industry.finance": "Finance",
+    "companies.industry.healthcare": "Santé",
+    "companies.industry.retail": "Commerce",
+    "companies.industry.manufacturing": "Industrie",
+    "companies.industry.education": "Éducation",
+    "companies.industry.media": "Médias",
+    "companies.industry.consulting": "Conseil",
+    "companies.industry.real-estate": "Immobilier",
+    "companies.industry.other": "Autre",
+    "people.lifecycleStage.subscriber": "Abonné",
+    "people.lifecycleStage.lead": "Lead",
+    "people.lifecycleStage.mql": "MQL",
+    "people.lifecycleStage.sql": "SQL",
+    "people.lifecycleStage.opportunity": "Opportunité",
+    "people.lifecycleStage.customer": "Client",
+    "people.lifecycleStage.evangelist": "Ambassadeur",
+    "people.leadSource.website": "Site web",
+    "people.leadSource.referral": "Recommandation",
+    "people.leadSource.event": "Événement",
+    "people.leadSource.outbound": "Prospection",
+    "people.leadSource.partner": "Partenaire",
+    "people.leadSource.ads": "Publicité",
+    "people.leadSource.social": "Réseaux sociaux",
+    "people.leadSource.other": "Autre"
+  },
+  stages: {
+    new: "Nouveau",
+    qualified: "Qualifié",
+    proposal: "Proposition",
+    negotiation: "Négociation",
+    won: "Gagné",
+    lost: "Perdu"
+  },
+  pipelines: { sales: "Ventes" },
+  views: {
+    "companies-all": "Toutes les entreprises",
+    "people-all": "Tous les contacts",
+    "deals-all": "Toutes les affaires",
+    "deals-pipeline": "Pipeline"
+  }
+};
+const BY_LANG = { fr: FR };
+function labelsFor(locale) {
+  if (!locale) return null;
+  return BY_LANG[locale.toLowerCase().split(/[-_]/)[0]] ?? null;
+}
+function localizeObjects(objects, locale) {
+  const L = labelsFor(locale);
+  if (!L) return objects;
+  const stage = (id, label) => L.stages[id] ?? label;
+  return objects.map((o) => {
+    const names = L.objects[o.id];
+    return {
+      ...o,
+      ...names ? { labelSingular: names.singular, labelPlural: names.plural } : {},
+      fields: o.fields.map((f) => ({
+        ...f,
+        label: L.fields[`${o.id}.${f.id}`] ?? f.label,
+        ...f.options ? {
+          options: f.options.map((opt) => ({
+            ...opt,
+            label: o.id === "deals" && f.id === "stage" ? stage(opt.id, opt.label) : o.id === "deals" && f.id === "pipeline" ? L.pipelines[opt.id] ?? opt.label : L.options[`${o.id}.${f.id}.${opt.id}`] ?? opt.label
+          }))
+        } : {}
+      }))
+    };
+  });
+}
+function localizePipeline(pipeline, locale) {
+  const L = labelsFor(locale);
+  if (!L) return pipeline;
+  return {
+    ...pipeline,
+    name: L.pipelines[pipeline.id] ?? pipeline.name,
+    stages: pipeline.stages.map((s) => ({ ...s, label: L.stages[s.id] ?? s.label }))
+  };
+}
+function localizeView(view, locale) {
+  const L = labelsFor(locale);
+  if (!L) return view;
+  return { ...view, name: L.views[view.id] ?? view.name };
+}
+const SCHEMA_MIGRATIONS = ["0.3.0-image-fields"];
+function schemaMigrationMutations(ctx) {
+  const report = { applied: [] };
+  const mutations = [];
+  const now = ctx.now();
+  const locale = settingsDoc(ctx.store)?.locale;
+  const standard = new Map(localizeObjects(standardObjects(now), locale).map((o) => [o.id, o]));
+  const migration = SCHEMA_MIGRATIONS[0];
+  for (const [objectId, fieldId] of Object.entries(STANDARD_IMAGE_FIELDS)) {
+    const current = objectOf(ctx.store, objectId);
+    if (!current || current.migrations?.includes(migration)) continue;
+    const def = standard.get(objectId)?.fields.find((f) => f.id === fieldId);
+    if (!def) continue;
+    const added = [];
+    const fields = [...current.fields];
+    if (!fields.some((f) => f.id === fieldId)) {
+      fields.push({ ...def });
+      added.push(fieldId);
+    }
+    const patch = { migrations: [...current.migrations ?? [], migration], updatedAt: now };
+    if (added.length) patch.fields = fields;
+    const field = fields.find((f) => f.id === fieldId);
+    if (!current.imageField && field?.type === "image") patch.imageField = fieldId;
+    mutations.push({ op: "patch", collection: "objects", id: objectId, fields: patch });
+    report.applied.push({ object: objectId, migration, added });
+  }
+  return { mutations, report };
+}
+async function migrateSchema(ctx) {
+  assertCan(ctx, "schema.write");
+  const { mutations, report } = schemaMigrationMutations(ctx);
+  if (mutations.length) await ctx.store.write(mutations, { message: "Upgrade the schema (image fields)" });
+  return report;
+}
+const migrate = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  SCHEMA_MIGRATIONS,
+  migrateSchema,
+  schemaMigrationMutations
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  SCHEMA_MIGRATIONS as S,
+  localizePipeline as a,
+  localizeView as b,
+  migrate as c,
+  localizeObjects as l,
+  migrateSchema as m,
+  schemaMigrationMutations as s
+};

package/dist/agent/chunks/modules-CqdVQVJb.mjs

@@ -0,0 +1,177 @@
+import { createRequire as __acrmRequire } from "node:module";
+import { fileURLToPath as __acrmPath } from "node:url";
+import { dirname as __acrmDirname } from "node:path";
+const require2 = __acrmRequire(import.meta.url);
+const __filename = __acrmPath(import.meta.url);
+const __dirname = __acrmDirname(__filename);
+import { c as REQUIRED_MODULES, d as disabledFromDoc, B as BUILTIN_MODULES, M as MODULES_CONFIG_ID, i as isCompatibleApiVersion, e as builtinModule } from "./api-B6OqNVWp.mjs";
+import { assertCan, OpsError } from "./context-CxFfqS4D.mjs";
+import { assertNoSecrets } from "./settings-BtvR_jdm.mjs";
+import { extensionDocsOf, extensionDocOf } from "./store-5gqRSKXg.mjs";
+import "./pluginRegistry-DyHtlkcr.mjs";
+import "./runtimeConfig-CCOFg1RM.mjs";
+function configDoc(store) {
+  return store.get("config", MODULES_CONFIG_ID);
+}
+function moduleExtensions(store) {
+  return extensionDocsOf(store).filter((e) => e.kind === "module");
+}
+function moduleStates(store) {
+  const disabled = disabledFromDoc(configDoc(store));
+  const list = BUILTIN_MODULES.map((m) => ({
+    id: m.id,
+    source: "builtin",
+    name: m.label,
+    description: m.summary,
+    nameKey: m.name,
+    descriptionKey: m.description,
+    icon: m.icon,
+    category: m.category,
+    required: !!m.required,
+    enabled: !disabled.has(m.id),
+    dependsOn: m.dependsOn ?? [],
+    dependents: [],
+    missingDependencies: [],
+    objects: m.objects ?? [],
+    ...m.settingsSection ? { settingsSection: m.settingsSection } : {}
+  }));
+  for (const e of moduleExtensions(store)) {
+    const incompatible = !isCompatibleApiVersion(e.manifest.apiVersion);
+    list.push({
+      id: e.id,
+      source: "extension",
+      name: e.manifest.name,
+      description: e.manifest.description,
+      icon: e.manifest.icon ?? "Puzzle",
+      category: e.manifest.category ?? "customisation",
+      required: false,
+      enabled: !!e.enabled && !incompatible,
+      dependsOn: e.manifest.dependsOn ?? [],
+      dependents: [],
+      missingDependencies: [],
+      objects: [],
+      version: e.manifest.version,
+      ...incompatible ? { incompatible: true } : {}
+    });
+  }
+  const byId = new Map(list.map((m) => [m.id, m]));
+  for (const m of list) {
+    for (const d of m.dependsOn) {
+      byId.get(d)?.dependents.push(m.id);
+      if (!byId.get(d)?.enabled) m.missingDependencies.push(d);
+    }
+  }
+  return list;
+}
+function isModuleEnabled(store, id) {
+  const m = moduleStates(store).find((x) => x.id === id);
+  return m ? m.enabled : true;
+}
+function disabledObjectIds(store) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of moduleStates(store)) if (!m.enabled) for (const o of m.objects) out.add(o);
+  return out;
+}
+function listModules(ctx) {
+  assertCan(ctx, "settings.read");
+  return moduleStates(ctx.store);
+}
+function getModule(ctx, id) {
+  const m = listModules(ctx).find((x) => x.id === id);
+  if (!m) throw new OpsError("notFound", `Unknown module "${id}". Modules: ${listModules(ctx).map((x) => x.id).join(", ")}.`);
+  return m;
+}
+async function setModuleEnabled(ctx, id, enabled, opts = {}) {
+  assertCan(ctx, "modules.write");
+  const states = moduleStates(ctx.store);
+  const byId = new Map(states.map((m) => [m.id, m]));
+  const target = byId.get(id);
+  if (!target) throw new OpsError("notFound", `Unknown module "${id}". Modules: ${states.map((m) => m.id).join(", ")}.`);
+  if (!enabled && target.required) throw new OpsError("invalid", `"${target.name}" is required and can't be disabled. Required modules: ${REQUIRED_MODULES.join(", ")}.`);
+  if (enabled && target.incompatible) throw new OpsError("invalid", `"${target.name}" targets an unsupported extension API version — install an updated version.`);
+  const toChange = /* @__PURE__ */ new Map();
+  const visit = (mid) => {
+    const m = byId.get(mid);
+    if (!m || toChange.has(mid)) return;
+    toChange.set(mid, enabled);
+    const next = enabled ? m.dependsOn : m.dependents;
+    for (const n of next) {
+      const other = byId.get(n);
+      if (enabled && !other) throw new OpsError("conflict", `"${target.name}" depends on "${n}", which is not installed.`, { missing: [n] });
+      if (!other || other.enabled === enabled) continue;
+      if (!opts.cascade) {
+        const blockers = next.filter((x) => byId.get(x) && byId.get(x).enabled !== enabled);
+        throw new OpsError(
+          "conflict",
+          enabled ? `"${m.name}" needs ${blockers.map((b) => `"${byId.get(b).name}"`).join(", ")} — enable ${blockers.length > 1 ? "them" : "it"} first (or pass cascade).` : `${blockers.map((b) => `"${byId.get(b).name}"`).join(", ")} depend${blockers.length > 1 ? "" : "s"} on "${m.name}" — disable ${blockers.length > 1 ? "them" : "it"} first (or pass cascade).`,
+          { blockers }
+        );
+      }
+      if (!enabled && other.required) throw new OpsError("conflict", `Required module "${other.name}" depends on "${m.name}".`);
+      visit(n);
+    }
+  };
+  visit(id);
+  const changed = [...toChange].filter(([mid, on]) => byId.get(mid).enabled !== on).map(([mid, on]) => ({ id: mid, enabled: on }));
+  if (!changed.length) return { id, enabled, changed: [] };
+  const mutations = [];
+  const builtinChanges = changed.filter((c) => byId.get(c.id).source === "builtin");
+  if (builtinChanges.length) {
+    const current = configDoc(ctx.store);
+    const disabled = disabledFromDoc(current);
+    for (const c of builtinChanges) {
+      if (c.enabled) disabled.delete(c.id);
+      else disabled.add(c.id);
+    }
+    const list = BUILTIN_MODULES.map((m) => m.id).filter((m) => disabled.has(m));
+    if (current) mutations.push({ op: "patch", collection: "config", id: MODULES_CONFIG_ID, fields: { disabled: list, updatedAt: ctx.now() } });
+    else mutations.push({ op: "set", collection: "config", doc: { id: MODULES_CONFIG_ID, disabled: list, config: {}, updatedAt: ctx.now() } });
+  }
+  for (const c of changed.filter((x) => byId.get(x.id).source === "extension")) {
+    mutations.push({ op: "patch", collection: "extensions", id: c.id, fields: { enabled: c.enabled, updatedAt: ctx.now() } });
+  }
+  await ctx.store.write(mutations, { message: `${enabled ? "Enable" : "Disable"} module ${id}` });
+  ctx.log?.(`modules: ${changed.map((c) => `${c.id}=${c.enabled ? "on" : "off"}`).join(", ")}`);
+  return { id, enabled, changed };
+}
+function assertKnownModule(store, id) {
+  if (!builtinModule(id) && !extensionDocOf(store, id)) throw new OpsError("notFound", `Unknown module "${id}".`);
+}
+function getModuleConfig(ctx, id) {
+  assertCan(ctx, "settings.read");
+  return configDoc(ctx.store)?.config?.[id];
+}
+const MAX_MODULE_CONFIG = 256 * 1024;
+async function setModuleConfig(ctx, id, value) {
+  assertCan(ctx, "modules.write");
+  assertKnownModule(ctx.store, id);
+  if (value !== null && value !== void 0) {
+    let json;
+    try {
+      json = JSON.stringify(value);
+    } catch {
+      throw new OpsError("validation", "Module configuration must be JSON-serialisable.");
+    }
+    if (json === void 0) throw new OpsError("validation", "Module configuration must be JSON-serialisable.");
+    if (json.length > MAX_MODULE_CONFIG) throw new OpsError("validation", `Module configuration is larger than ${MAX_MODULE_CONFIG / 1024} KB.`);
+    assertNoSecrets(value);
+  }
+  const current = configDoc(ctx.store);
+  const next = value === null || value === void 0 ? void 0 : JSON.parse(JSON.stringify(value));
+  if (current) {
+    await ctx.store.write([{ op: "patch", collection: "config", id: MODULES_CONFIG_ID, fields: { [`config.${id}`]: next, updatedAt: ctx.now() } }], { message: `Configure module ${id}` });
+  } else {
+    await ctx.store.write([{ op: "set", collection: "config", doc: { id: MODULES_CONFIG_ID, disabled: [], config: next === void 0 ? {} : { [id]: next }, updatedAt: ctx.now() } }], { message: `Configure module ${id}` });
+  }
+  return getModuleConfig(ctx, id);
+}
+export {
+  disabledObjectIds,
+  getModule,
+  getModuleConfig,
+  isModuleEnabled,
+  listModules,
+  moduleStates,
+  setModuleConfig,
+  setModuleEnabled
+};

package/dist/agent/chunks/nodeImport-BPCt5uMu.mjs

@@ -0,0 +1,38 @@
+import { createRequire as __acrmRequire } from "node:module";
+import { fileURLToPath as __acrmPath } from "node:url";
+import { dirname as __acrmDirname } from "node:path";
+const require2 = __acrmRequire(import.meta.url);
+const __filename = __acrmPath(import.meta.url);
+const __dirname = __acrmDirname(__filename);
+import { mkdtemp, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { resolve, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { g as RUNTIME_MODULES } from "./api-B6OqNVWp.mjs";
+import { rewriteRuntimeImports } from "./package-DWbn3t2R.mjs";
+import "./index-w03ReRs4.mjs";
+import "./_commonjsHelpers-ClciMIcB.mjs";
+import "stream";
+import "events";
+import "buffer";
+import "util";
+function createNodeImportBundle(opts) {
+  const runtimeDir = resolve(opts.runtimeDir);
+  return async (code, info) => {
+    const dir = await mkdtemp(join(opts.tmpDir ?? tmpdir(), "agentcrm-ext-"));
+    const file = join(dir, `${info.id}-${info.version}.mjs`);
+    try {
+      const rewritten = rewriteRuntimeImports(code, (spec) => pathToFileURL(join(runtimeDir, RUNTIME_MODULES[spec])).href);
+      await writeFile(file, rewritten, "utf8");
+      return await import(
+        /* @vite-ignore */
+        pathToFileURL(file).href
+      );
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  };
+}
+export {
+  createNodeImportBundle
+};

package/dist/agent/chunks/package-DWbn3t2R.mjs

@@ -0,0 +1,194 @@
+import { createRequire as __acrmRequire } from "node:module";
+import { fileURLToPath as __acrmPath } from "node:url";
+import { dirname as __acrmDirname } from "node:path";
+const require2 = __acrmRequire(import.meta.url);
+const __filename = __acrmPath(import.meta.url);
+const __dirname = __acrmDirname(__filename);
+import { J as JSZip } from "./index-w03ReRs4.mjs";
+import { a as EXTENSION_LIMITS, R as RUNTIME_SPECIFIERS, i as isCompatibleApiVersion, b as EXTENSION_MIN_API_VERSION, E as EXTENSION_API_VERSION, B as BUILTIN_MODULES, f as MODULE_CATEGORIES } from "./api-B6OqNVWp.mjs";
+import "./_commonjsHelpers-ClciMIcB.mjs";
+import "stream";
+import "events";
+import "buffer";
+import "util";
+class ExtensionPackageError extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "ExtensionPackageError";
+  }
+}
+const EXTENSION_ID_RE = /^[a-z][a-z0-9-]{1,48}[a-z0-9]$/;
+const SEMVER_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+const RESERVED_EXTENSION_IDS = [...BUILTIN_MODULES.map((m) => m.id), "agentcrm", "core", "runtime", "admin", "app", "custom", "default"];
+const MANIFEST_KEYS = ["id", "kind", "name", "version", "apiVersion", "description", "author", "homepage", "entry", "style", "icon", "category", "dependsOn"];
+function byteLength(s) {
+  return new TextEncoder().encode(s).length;
+}
+function validateManifest(raw) {
+  const errors = [];
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new ExtensionPackageError("invalidManifest", "manifest.json must be a JSON object.");
+  const m = raw;
+  const str = (k, required, max = 200) => {
+    const v = m[k];
+    if (v === void 0 || v === null || v === "") {
+      if (required) errors.push(`"${k}" is required.`);
+      return void 0;
+    }
+    if (typeof v !== "string") {
+      errors.push(`"${k}" must be a string.`);
+      return void 0;
+    }
+    if (v.length > max) errors.push(`"${k}" is too long (max ${max} characters).`);
+    return v.trim();
+  };
+  for (const k of Object.keys(m)) if (!MANIFEST_KEYS.includes(k)) errors.push(`Unknown key "${k}".`);
+  const id = str("id", true, 50);
+  if (id && !EXTENSION_ID_RE.test(id)) errors.push(`"id" must be 3–50 characters: lowercase letters, digits and dashes, starting with a letter (got "${id}").`);
+  if (id && RESERVED_EXTENSION_IDS.includes(id)) errors.push(`"id" "${id}" is reserved (built-in module or reserved word).`);
+  const kind = str("kind", true, 10);
+  if (kind && kind !== "module" && kind !== "theme") errors.push(`"kind" must be "module" or "theme".`);
+  const name = str("name", true, 80);
+  const version = str("version", true, 40);
+  if (version && !SEMVER_RE.test(version)) errors.push(`"version" must be semver (1.2.3), got "${version}".`);
+  const apiVersion = str("apiVersion", true, 20);
+  const description = str("description", false, 500) ?? "";
+  const author = str("author", false, 120);
+  const homepage = str("homepage", false, 300);
+  if (homepage && !/^https?:\/\/\S+$/i.test(homepage)) errors.push(`"homepage" must be an http(s) URL.`);
+  const entry = str("entry", false, 40) ?? "bundle.js";
+  if (entry !== "bundle.js") errors.push(`"entry" must be "bundle.js".`);
+  const style = str("style", false, 40);
+  if (style !== void 0 && style !== "style.css") errors.push(`"style" must be "style.css" when set.`);
+  const icon = str("icon", false, 60);
+  if (icon && !/^[A-Z][A-Za-z0-9]*$/.test(icon)) errors.push(`"icon" must be a lucide icon name in PascalCase ("Target").`);
+  const category = str("category", false, 30);
+  if (category && !MODULE_CATEGORIES.includes(category)) errors.push(`"category" must be one of ${MODULE_CATEGORIES.join(", ")}.`);
+  let dependsOn;
+  if (m.dependsOn !== void 0) {
+    if (!Array.isArray(m.dependsOn) || !m.dependsOn.every((d) => typeof d === "string" && /^[a-z][a-z0-9-]*$/.test(d))) errors.push(`"dependsOn" must be an array of module ids.`);
+    else dependsOn = [...new Set(m.dependsOn)].filter((d) => d !== id);
+  }
+  if (kind === "theme" && (category || dependsOn?.length)) errors.push(`Themes can't declare "category" or "dependsOn".`);
+  if (errors.length) throw new ExtensionPackageError("invalidManifest", `Invalid manifest.json: ${errors.join(" ")}`, errors);
+  if (!isCompatibleApiVersion(apiVersion)) {
+    throw new ExtensionPackageError("incompatibleApi", `apiVersion ${apiVersion} is not supported by this admin (supported: ${EXTENSION_MIN_API_VERSION} – ${EXTENSION_API_VERSION}).`);
+  }
+  return {
+    id,
+    kind,
+    name,
+    version,
+    apiVersion,
+    description,
+    ...author ? { author } : {},
+    ...homepage ? { homepage } : {},
+    entry: "bundle.js",
+    ...style ? { style: "style.css" } : {},
+    ...icon ? { icon } : {},
+    ...category ? { category } : {},
+    ...dependsOn?.length ? { dependsOn } : {}
+  };
+}
+function bundleImports(code) {
+  const out = /* @__PURE__ */ new Set();
+  const re = /(?:\bimport\s*(?:[\w*{}\s,$]+?\s*from\s*)?|\bexport\s*(?:\*|\{[^}]*\})\s*from\s*|\bimport\s*\(\s*)["']([^"']+)["']/g;
+  for (const m of code.matchAll(re)) {
+    const spec = m[1];
+    if (!spec.startsWith(".") && !spec.startsWith("/") && !/^[a-z]+:/i.test(spec)) out.add(spec);
+  }
+  return [...out].sort();
+}
+function rewriteRuntimeImports(code, resolve) {
+  const specs = RUNTIME_SPECIFIERS.map((s) => s.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&")).join("|");
+  const re = new RegExp(`(\\bfrom\\s*|\\bimport\\s*\\(\\s*|\\bimport\\s+)(["'])(${specs})\\2`, "g");
+  return code.replace(re, (_m, prefix, quote, spec) => `${prefix}${quote}${resolve(spec)}${quote}`);
+}
+function validatePackage(pkg) {
+  const raw = pkg.files;
+  const manifest = validateManifest(pkg.manifest);
+  const bundle = raw["bundle.js"];
+  if (typeof bundle !== "string" || !bundle.trim()) throw new ExtensionPackageError("missingEntry", "The package has no bundle.js.");
+  if (byteLength(bundle) > EXTENSION_LIMITS.bundle) throw new ExtensionPackageError("tooLarge", `bundle.js is ${(byteLength(bundle) / 1024 / 1024).toFixed(2)} MB — the limit is ${EXTENSION_LIMITS.bundle / 1024 / 1024} MB.`);
+  const unknown = bundleImports(bundle).filter((s) => !RUNTIME_SPECIFIERS.includes(s));
+  if (unknown.length) {
+    throw new ExtensionPackageError("invalidBundle", `bundle.js imports modules the admin doesn't provide: ${unknown.join(", ")}. Bundle them, or import from: ${RUNTIME_SPECIFIERS.join(", ")}.`, unknown);
+  }
+  if (!/\bexport\s*(?:default\b|\{[^}]*\bas\s+default\b)/.test(bundle)) throw new ExtensionPackageError("invalidBundle", "bundle.js must have a default export (defineModule / defineTheme).");
+  const files = { "bundle.js": bundle };
+  const style = raw["style.css"];
+  if (manifest.style) {
+    if (typeof style !== "string") throw new ExtensionPackageError("missingEntry", 'manifest.json declares "style": "style.css" but the package has no style.css.');
+  }
+  if (typeof style === "string" && style.trim()) {
+    if (byteLength(style) > EXTENSION_LIMITS.style) throw new ExtensionPackageError("tooLarge", `style.css is larger than ${EXTENSION_LIMITS.style / 1024} KB.`);
+    files["style.css"] = style;
+  }
+  return { manifest, files };
+}
+async function readExtensionZip(data) {
+  const size = data instanceof Uint8Array ? data.byteLength : data instanceof ArrayBuffer ? data.byteLength : data.size;
+  if (size > EXTENSION_LIMITS.zip) throw new ExtensionPackageError("tooLarge", `The ZIP is larger than ${EXTENSION_LIMITS.zip / 1024 / 1024} MB.`);
+  let zip;
+  try {
+    zip = await JSZip.loadAsync(data);
+  } catch (err) {
+    throw new ExtensionPackageError("invalidZip", `Not a valid ZIP file (${err.message}).`);
+  }
+  const names = Object.keys(zip.files).filter((n) => !zip.files[n].dir && !n.startsWith("__MACOSX/") && !n.split("/").pop().startsWith("."));
+  let prefix = "";
+  if (!names.includes("manifest.json")) {
+    const candidates = names.filter((n) => /^[^/]+\/manifest\.json$/.test(n));
+    if (candidates.length !== 1) throw new ExtensionPackageError("missingManifest", "The ZIP has no manifest.json at its root.");
+    prefix = candidates[0].slice(0, -"manifest.json".length);
+  }
+  const read = async (name) => {
+    const f = zip.file(prefix + name);
+    return f ? f.async("string") : void 0;
+  };
+  const manifestText = await read("manifest.json");
+  if (byteLength(manifestText) > EXTENSION_LIMITS.manifest) throw new ExtensionPackageError("tooLarge", "manifest.json is too large.");
+  let manifest;
+  try {
+    manifest = JSON.parse(manifestText);
+  } catch (err) {
+    throw new ExtensionPackageError("invalidManifest", `manifest.json is not valid JSON (${err.message}).`);
+  }
+  const files = { "bundle.js": await read("bundle.js"), "style.css": await read("style.css") };
+  return validatePackage({ manifest, files });
+}
+async function packExtension(pkg) {
+  const valid = validatePackage(pkg);
+  const zip = new JSZip();
+  zip.file("manifest.json", JSON.stringify(valid.manifest, null, 2) + "\n");
+  zip.file("bundle.js", valid.files["bundle.js"]);
+  if (valid.files["style.css"]) zip.file("style.css", valid.files["style.css"]);
+  return zip.generateAsync({ type: "uint8array", compression: "DEFLATE", compressionOptions: { level: 9 } });
+}
+function fingerprint(manifest, files) {
+  let h = 2166136261;
+  const feed = (s) => {
+    for (let i = 0; i < s.length; i++) {
+      h ^= s.charCodeAt(i);
+      h = Math.imul(h, 16777619) >>> 0;
+    }
+  };
+  feed(manifest.version);
+  feed(files["bundle.js"]);
+  feed(files["style.css"] ?? "");
+  return `${manifest.version}-${h.toString(16).padStart(8, "0")}`;
+}
+export {
+  EXTENSION_ID_RE,
+  ExtensionPackageError,
+  RESERVED_EXTENSION_IDS,
+  SEMVER_RE,
+  bundleImports,
+  fingerprint,
+  packExtension,
+  readExtensionZip,
+  rewriteRuntimeImports,
+  validateManifest,
+  validatePackage
+};