@lucern/pack-host 0.1.0-alpha.2

package/dist/runtime.js

@@ -0,0 +1,638 @@
+import { z } from 'zod';
+
+// src/dependencyResolution.ts
+function toIssue(code, message, path, severity = "error") {
+  return {
+    code,
+    severity,
+    message,
+    path
+  };
+}
+function buildManifestMap(manifests) {
+  return new Map(manifests.map((manifest) => [manifest.key, manifest]));
+}
+function walkDependencyClosure(manifestKey, manifestsByKey, path, closure, issues) {
+  const manifest = manifestsByKey.get(manifestKey);
+  if (!manifest) {
+    return;
+  }
+  for (const dependency of manifest.dependencies) {
+    if (!manifestsByKey.has(dependency)) {
+      issues.push(
+        toIssue(
+          "PACK_DEPENDENCY_MISSING",
+          `Pack "${manifestKey}" depends on unknown pack "${dependency}".`,
+          `dependencies:${manifestKey}`
+        )
+      );
+      continue;
+    }
+    if (path.includes(dependency)) {
+      const cycle = [...path, dependency].join(" -> ");
+      issues.push(
+        toIssue(
+          "PACK_DEPENDENCY_CYCLE",
+          `Cycle detected: ${cycle}`,
+          `dependencies:${manifestKey}`
+        )
+      );
+      continue;
+    }
+    if (closure.has(dependency)) {
+      continue;
+    }
+    closure.add(dependency);
+    walkDependencyClosure(
+      dependency,
+      manifestsByKey,
+      [...path, dependency],
+      closure,
+      issues
+    );
+  }
+}
+function resolvePackDependencyGraph(manifests) {
+  const issues = [];
+  const manifestsByKey = buildManifestMap(manifests);
+  const indegree = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const manifest of manifests) {
+    indegree.set(manifest.key, indegree.get(manifest.key) ?? 0);
+    adjacency.set(manifest.key, []);
+  }
+  for (const manifest of manifests) {
+    for (const dependency of manifest.dependencies) {
+      if (!manifestsByKey.has(dependency)) {
+        issues.push(
+          toIssue(
+            "PACK_DEPENDENCY_MISSING",
+            `Pack "${manifest.key}" depends on unknown pack "${dependency}".`,
+            `dependencies:${manifest.key}`
+          )
+        );
+        continue;
+      }
+      const dependencyDependents = adjacency.get(dependency) ?? [];
+      dependencyDependents.push(manifest.key);
+      adjacency.set(dependency, dependencyDependents);
+      indegree.set(manifest.key, (indegree.get(manifest.key) ?? 0) + 1);
+    }
+  }
+  const queue = [...indegree.entries()].filter(([, value]) => value === 0).map(([packKey]) => packKey).sort();
+  const orderedPackKeys = [];
+  while (queue.length > 0) {
+    const nextKey = queue.shift();
+    if (!nextKey) {
+      break;
+    }
+    orderedPackKeys.push(nextKey);
+    const dependents = adjacency.get(nextKey) ?? [];
+    for (const dependent of dependents) {
+      const current = indegree.get(dependent) ?? 0;
+      const updated = current - 1;
+      indegree.set(dependent, updated);
+      if (updated === 0) {
+        queue.push(dependent);
+      }
+    }
+    queue.sort();
+  }
+  if (orderedPackKeys.length !== manifestsByKey.size) {
+    const unresolved = [...indegree.entries()].filter(([, value]) => value > 0).map(([key]) => key).sort();
+    issues.push(
+      toIssue(
+        "PACK_DEPENDENCY_CYCLE",
+        `Dependency graph is not acyclic; unresolved packs: ${unresolved.join(", ")}`,
+        "dependencies"
+      )
+    );
+  }
+  const dependencyClosureByPack = {};
+  for (const manifest of manifests) {
+    const closure = /* @__PURE__ */ new Set();
+    walkDependencyClosure(
+      manifest.key,
+      manifestsByKey,
+      [manifest.key],
+      closure,
+      issues
+    );
+    dependencyClosureByPack[manifest.key] = [...closure].sort();
+  }
+  return {
+    orderedPackKeys,
+    dependencyClosureByPack,
+    issues,
+    valid: issues.every((issue) => issue.severity !== "error")
+  };
+}
+var manifestKeyPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*-v[0-9]+$/;
+var semverPattern = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/;
+var appPackManifestSchema = z.object({
+  key: z.string().regex(manifestKeyPattern),
+  name: z.string().min(1),
+  version: z.string().regex(semverPattern),
+  lifecycle: z.enum(["active", "beta", "experimental"]),
+  category: z.enum([
+    "conversation",
+    "research",
+    "graph",
+    "analytics",
+    "workflow",
+    "decision",
+    "news",
+    "documents",
+    "identity",
+    "operations",
+    "domain"
+  ]),
+  description: z.string().min(1),
+  dependencies: z.array(z.string().min(1)),
+  capabilityFlags: z.array(z.string().min(1)),
+  routeNamespace: z.object({
+    web: z.array(z.string().min(1)),
+    api: z.array(z.string().min(1))
+  }),
+  surfaces: z.object({
+    components: z.array(z.string().min(1)),
+    convex: z.array(z.string().min(1)),
+    tools: z.array(z.string().min(1))
+  }),
+  policyProfile: z.object({
+    audiences: z.array(z.string().min(1)).min(1),
+    rules: z.array(
+      z.object({
+        resource: z.enum([
+          "project",
+          "node",
+          "edge",
+          "artifact",
+          "report_section",
+          "tool_action",
+          "task",
+          "user_profile",
+          "team_analytics"
+        ]),
+        actions: z.array(z.enum(["read", "summarize", "export", "mutate", "admin"])).min(1),
+        notes: z.string().optional()
+      })
+    ).min(1)
+  }),
+  dataContract: z.object({
+    requiredNodeTypes: z.array(z.string().min(1)),
+    requiredEdgeTypes: z.array(z.string().min(1)),
+    requiredTables: z.array(z.string().min(1)).min(1),
+    projectionBehavior: z.enum([
+      "none",
+      "inherits_policy",
+      "projection_required"
+    ])
+  }),
+  templates: z.object({
+    workflows: z.array(z.string().min(1)),
+    prompts: z.array(z.string().min(1)),
+    reports: z.array(z.string().min(1)),
+    uiLabels: z.array(z.string().min(1))
+  }),
+  testSuite: z.object({
+    parity: z.array(z.string().min(1)).min(1),
+    policy: z.array(z.string().min(1)).min(1),
+    contract: z.array(z.string().min(1)).min(1)
+  }),
+  sharedServices: z.array(
+    z.object({
+      service: z.enum([
+        "decision-kernel",
+        "knowledge-compiler",
+        "learning-loop"
+      ]),
+      mode: z.enum(["required", "optional"]),
+      contracts: z.array(z.string().min(1)).min(1)
+    })
+  )
+});
+function toIssue2(code, message, path, severity = "error") {
+  return {
+    code,
+    severity,
+    message,
+    path
+  };
+}
+function collectDuplicateValues(values) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    counts.set(value, (counts.get(value) ?? 0) + 1);
+  }
+  return [...counts.entries()].filter(([, count]) => count > 1).map(([value]) => value).sort();
+}
+function collectUnknownValues(values, knownValues) {
+  const known = new Set(knownValues);
+  return values.filter((value) => !known.has(value));
+}
+function validateManifestShape(manifest) {
+  const parsed = appPackManifestSchema.safeParse(manifest);
+  if (parsed.success) {
+    return [];
+  }
+  return parsed.error.issues.map(
+    (issue) => toIssue2(
+      "PACK_MANIFEST_SCHEMA_INVALID",
+      issue.message,
+      issue.path.join(".") || "(root)"
+    )
+  );
+}
+function validateManifestUniqueness(manifest) {
+  const issues = [];
+  const duplicateDependencies = collectDuplicateValues(manifest.dependencies);
+  if (duplicateDependencies.length > 0) {
+    issues.push(
+      toIssue2(
+        "PACK_DEPENDENCIES_DUPLICATE",
+        `Duplicate dependencies declared: ${duplicateDependencies.join(", ")}`,
+        "dependencies"
+      )
+    );
+  }
+  if (manifest.dependencies.includes(manifest.key)) {
+    issues.push(
+      toIssue2(
+        "PACK_DEPENDENCY_SELF_REFERENCE",
+        `Pack "${manifest.key}" cannot depend on itself.`,
+        "dependencies"
+      )
+    );
+  }
+  const duplicateCapabilities = collectDuplicateValues(
+    manifest.capabilityFlags
+  );
+  if (duplicateCapabilities.length > 0) {
+    issues.push(
+      toIssue2(
+        "PACK_CAPABILITIES_DUPLICATE",
+        `Duplicate capability flags declared: ${duplicateCapabilities.join(", ")}`,
+        "capabilityFlags"
+      )
+    );
+  }
+  const duplicateWebRoutes = collectDuplicateValues(
+    manifest.routeNamespace.web
+  );
+  if (duplicateWebRoutes.length > 0) {
+    issues.push(
+      toIssue2(
+        "PACK_WEB_ROUTES_DUPLICATE",
+        `Duplicate web routes declared: ${duplicateWebRoutes.join(", ")}`,
+        "routeNamespace.web"
+      )
+    );
+  }
+  const duplicateApiRoutes = collectDuplicateValues(
+    manifest.routeNamespace.api
+  );
+  if (duplicateApiRoutes.length > 0) {
+    issues.push(
+      toIssue2(
+        "PACK_API_ROUTES_DUPLICATE",
+        `Duplicate api routes declared: ${duplicateApiRoutes.join(", ")}`,
+        "routeNamespace.api"
+      )
+    );
+  }
+  const duplicateServices = collectDuplicateValues(
+    manifest.sharedServices.map((integration) => integration.service)
+  );
+  if (duplicateServices.length > 0) {
+    issues.push(
+      toIssue2(
+        "PACK_SHARED_SERVICE_DUPLICATE",
+        `Duplicate shared-service integrations declared: ${duplicateServices.join(", ")}`,
+        "sharedServices"
+      )
+    );
+  }
+  return issues;
+}
+function validateManifestDictionary(manifest, dictionary) {
+  if (!dictionary) {
+    return [];
+  }
+  const issues = [];
+  const unknownNodeTypes = collectUnknownValues(
+    manifest.dataContract.requiredNodeTypes,
+    dictionary.nodeTypes
+  );
+  const unknownEdgeTypes = collectUnknownValues(
+    manifest.dataContract.requiredEdgeTypes,
+    dictionary.edgeTypes
+  );
+  const unknownTables = collectUnknownValues(
+    manifest.dataContract.requiredTables,
+    dictionary.tables
+  );
+  if (unknownNodeTypes.length > 0) {
+    issues.push(
+      toIssue2(
+        "PACK_UNKNOWN_NODE_TYPES",
+        `Unknown required node types: ${unknownNodeTypes.join(", ")}`,
+        "dataContract.requiredNodeTypes"
+      )
+    );
+  }
+  if (unknownEdgeTypes.length > 0) {
+    issues.push(
+      toIssue2(
+        "PACK_UNKNOWN_EDGE_TYPES",
+        `Unknown required edge types: ${unknownEdgeTypes.join(", ")}`,
+        "dataContract.requiredEdgeTypes"
+      )
+    );
+  }
+  if (unknownTables.length > 0) {
+    issues.push(
+      toIssue2(
+        "PACK_UNKNOWN_TABLES",
+        `Unknown required tables: ${unknownTables.join(", ")}`,
+        "dataContract.requiredTables"
+      )
+    );
+  }
+  return issues;
+}
+function validateAppPackManifest(manifest, dictionary) {
+  const issues = [
+    ...validateManifestShape(manifest),
+    ...validateManifestUniqueness(manifest),
+    ...validateManifestDictionary(manifest, dictionary)
+  ];
+  return {
+    manifestKey: manifest.key,
+    valid: issues.every((issue) => issue.severity !== "error"),
+    issues
+  };
+}
+
+// src/namespacePolicy.ts
+var PACK_NAMESPACE_COLLISION_ALLOWLIST = [
+  {
+    surface: "web",
+    namespace: "/(chat)/chat/[id]",
+    allowedPackKeys: ["chat-v1", "philosophy-mode-v1"],
+    rationale: "Philosophy mode extends the chat surface and intentionally shares the chat detail route."
+  },
+  {
+    surface: "web",
+    namespace: "/(projects)/projects",
+    allowedPackKeys: ["deals-v1", "themes-v1"],
+    rationale: "Deals and themes intentionally share the topic index shell mounted under the legacy /projects customer-zero shell."
+  },
+  {
+    surface: "web",
+    namespace: "/(projects)/projects/[projectId]",
+    allowedPackKeys: ["deals-v1", "themes-v1"],
+    rationale: "Deals and themes intentionally share topic detail shell routing while the outer customer-zero shell still uses legacy project path segments."
+  },
+  {
+    surface: "api",
+    namespace: "/api/philosophy/get-profile",
+    allowedPackKeys: ["philosophy-mode-v1", "user-profiles-v1"],
+    rationale: "User profiles and philosophy mode share profile retrieval endpoint for compatibility."
+  },
+  {
+    surface: "api",
+    namespace: "/api/research/*",
+    allowedPackKeys: ["deals-v1", "themes-v1"],
+    rationale: "Deals and themes share research API namespace until productized API gateway split."
+  },
+  {
+    surface: "api",
+    namespace: "/api/reports/*",
+    allowedPackKeys: ["deals-v1", "decisions-v1", "themes-v1"],
+    rationale: "Domain packs intentionally consume shared report compiler endpoints in the same namespace."
+  }
+];
+function toIssue3(code, message, path, severity = "error") {
+  return {
+    code,
+    severity,
+    message,
+    path
+  };
+}
+function normalizeKeySet(values) {
+  return [...new Set(values)].sort().join("|");
+}
+function detectNamespaceCollisions(manifests) {
+  const collisions = [];
+  for (const surface of ["web", "api"]) {
+    const namespaceToPacks = /* @__PURE__ */ new Map();
+    for (const manifest of manifests) {
+      const namespaces = manifest.routeNamespace[surface];
+      for (const namespace of namespaces) {
+        const existing = namespaceToPacks.get(namespace) ?? [];
+        existing.push(manifest.key);
+        namespaceToPacks.set(namespace, existing);
+      }
+    }
+    for (const [namespace, packKeys] of namespaceToPacks.entries()) {
+      if (packKeys.length <= 1) {
+        continue;
+      }
+      collisions.push({
+        surface,
+        namespace,
+        packKeys: [...new Set(packKeys)].sort()
+      });
+    }
+  }
+  return collisions.sort((left, right) => {
+    if (left.surface !== right.surface) {
+      return left.surface.localeCompare(right.surface);
+    }
+    return left.namespace.localeCompare(right.namespace);
+  });
+}
+function validatePackNamespacePolicies(manifests) {
+  const issues = [];
+  const collisions = detectNamespaceCollisions(manifests);
+  const allowlistByKey = /* @__PURE__ */ new Map();
+  for (const entry of PACK_NAMESPACE_COLLISION_ALLOWLIST) {
+    const key = `${entry.surface}:${entry.namespace}`;
+    if (allowlistByKey.has(key)) {
+      issues.push(
+        toIssue3(
+          "PACK_NAMESPACE_ALLOWLIST_DUPLICATE",
+          `Duplicate allowlist entry for ${key}.`,
+          "namespacePolicy.allowlist"
+        )
+      );
+      continue;
+    }
+    allowlistByKey.set(key, entry);
+  }
+  for (const collision of collisions) {
+    const key = `${collision.surface}:${collision.namespace}`;
+    const allowlistEntry = allowlistByKey.get(key);
+    if (!allowlistEntry) {
+      issues.push(
+        toIssue3(
+          "PACK_NAMESPACE_COLLISION_UNAPPROVED",
+          `Unapproved ${collision.surface} namespace collision for "${collision.namespace}" across packs: ${collision.packKeys.join(", ")}`,
+          `namespacePolicy.${collision.surface}`
+        )
+      );
+      continue;
+    }
+    const collidedSet = normalizeKeySet(collision.packKeys);
+    const allowedSet = normalizeKeySet(allowlistEntry.allowedPackKeys);
+    if (collidedSet !== allowedSet) {
+      issues.push(
+        toIssue3(
+          "PACK_NAMESPACE_COLLISION_MISMATCH",
+          `Collision set mismatch for "${collision.namespace}". collided=${collidedSet} allowlist=${allowedSet}`,
+          `namespacePolicy.${collision.surface}`
+        )
+      );
+    }
+  }
+  return issues;
+}
+
+// src/serviceContracts.ts
+function hasSharedService(manifest, service) {
+  return manifest.sharedServices.some(
+    (integration) => integration.service === service
+  );
+}
+function hasDecisionIntegrationSignals(manifest) {
+  if (manifest.category === "decision") {
+    return true;
+  }
+  return manifest.capabilityFlags.some(
+    (flag) => flag.startsWith("decision.") || flag.includes("decision.integration")
+  );
+}
+function hasReportIntegrationSignals(manifest) {
+  if (manifest.templates.reports.length > 0) {
+    return true;
+  }
+  return manifest.routeNamespace.api.some(
+    (namespace) => namespace.includes("/api/reports")
+  );
+}
+function hasLearningIntegrationSignals(manifest) {
+  return manifest.capabilityFlags.some(
+    (flag) => flag.startsWith("learning.") || flag.includes("policy.injection") || flag.includes("adaptive-learning")
+  );
+}
+function validatePackSharedServiceContracts(manifests) {
+  const issues = [];
+  for (const manifest of manifests) {
+    if (hasReportIntegrationSignals(manifest) && !hasSharedService(manifest, "knowledge-compiler")) {
+      issues.push({
+        packKey: manifest.key,
+        service: "knowledge-compiler",
+        severity: "error",
+        code: "PACK_REPORT_SERVICE_MISSING",
+        message: "Pack declares report outputs/routes but is missing knowledge-compiler shared service integration."
+      });
+    }
+    if (hasDecisionIntegrationSignals(manifest) && !hasSharedService(manifest, "decision-kernel")) {
+      issues.push({
+        packKey: manifest.key,
+        service: "decision-kernel",
+        severity: "error",
+        code: "PACK_DECISION_SERVICE_MISSING",
+        message: "Pack declares decision behavior but is missing decision-kernel shared service integration."
+      });
+    }
+    if (hasLearningIntegrationSignals(manifest) && !hasSharedService(manifest, "learning-loop")) {
+      issues.push({
+        packKey: manifest.key,
+        service: "learning-loop",
+        severity: "error",
+        code: "PACK_LEARNING_SERVICE_MISSING",
+        message: "Pack declares adaptive learning behavior but is missing learning-loop shared service integration."
+      });
+    }
+  }
+  return issues;
+}
+
+// src/runtime.ts
+function toIssue4(code, message, path, severity = "error") {
+  return {
+    code,
+    severity,
+    message,
+    path
+  };
+}
+function validateRegistryIdentity(manifests) {
+  const issues = [];
+  const keyCounts = /* @__PURE__ */ new Map();
+  const identityCounts = /* @__PURE__ */ new Map();
+  for (const manifest of manifests) {
+    keyCounts.set(manifest.key, (keyCounts.get(manifest.key) ?? 0) + 1);
+    const identity = `${manifest.key}@${manifest.version}`;
+    identityCounts.set(identity, (identityCounts.get(identity) ?? 0) + 1);
+  }
+  for (const [key, count] of keyCounts.entries()) {
+    if (count > 1) {
+      issues.push(
+        toIssue4(
+          "PACK_KEY_DUPLICATE",
+          `Duplicate pack key registered: ${key}`,
+          "registry.keys"
+        )
+      );
+    }
+  }
+  for (const [identity, count] of identityCounts.entries()) {
+    if (count > 1) {
+      issues.push(
+        toIssue4(
+          "PACK_VERSION_DUPLICATE",
+          `Duplicate pack identity registered: ${identity}`,
+          "registry.versions"
+        )
+      );
+    }
+  }
+  return issues;
+}
+function validatePackRegistry(manifests, dictionary) {
+  const manifestResults = manifests.map(
+    (manifest) => validateAppPackManifest(manifest, dictionary)
+  );
+  const dependencyResult = resolvePackDependencyGraph(manifests);
+  const sharedServiceIssues = validatePackSharedServiceContracts(manifests).map(
+    (issue) => toIssue4(
+      issue.code,
+      `[${issue.packKey}] ${issue.message}`,
+      `sharedServices:${issue.packKey}`,
+      issue.severity
+    )
+  );
+  const namespaceIssues = validatePackNamespacePolicies(manifests);
+  const issues = [
+    ...validateRegistryIdentity(manifests),
+    ...manifestResults.flatMap((result) => result.issues),
+    ...dependencyResult.issues,
+    ...sharedServiceIssues,
+    ...namespaceIssues
+  ];
+  return {
+    valid: issues.every((issue) => issue.severity !== "error"),
+    manifestResults,
+    dependencyOrder: dependencyResult.orderedPackKeys,
+    dependencyClosureByPack: dependencyResult.dependencyClosureByPack,
+    issues
+  };
+}
+
+export { validatePackRegistry };
+//# sourceMappingURL=runtime.js.map
+//# sourceMappingURL=runtime.js.map