@lucern/pack-host 0.1.0-alpha.2

package/README.md

@@ -0,0 +1,64 @@
+# @lucern/pack-host
+
+## Overview
+
+`@lucern/pack-host` is the tenant-side surface for Lucern packs. It ships the
+canonical app-pack manifests, runtime registry helpers, lifecycle evaluation,
+and domain-pack shaping/runtime definitions that tenant Convex components use at
+runtime.
+
+## Install
+
+```bash
+pnpm add @lucern/pack-host convex
+```
+
+For Convex component composition:
+
+```ts
+import { defineApp } from "convex/server";
+import packHost from "@lucern/pack-host/convex.config";
+
+const app = defineApp();
+app.use(packHost);
+
+export default app;
+```
+
+## API
+
+Briefly:
+
+- `@lucern/pack-host` exports the runtime registry, lifecycle, validation, and
+  manifest helpers.
+- `@lucern/pack-host/registry` exposes `appPackRegistry`,
+  `listAppPackManifests`, and `validateAppPackRegistry`.
+- `@lucern/pack-host/domain-pack` exposes domain-pack contracts, shipped packs,
+  authoring helpers, and inquiry-shaping helpers.
+- `@lucern/pack-host/domain-pack/shaping` exposes shaping contribution helpers
+  for tenant runtime flows such as worktree auto-shaping.
+
+## Examples
+
+Validate the current tenant-visible registry:
+
+```ts
+import { validateAppPackRegistry } from "@lucern/pack-host/registry";
+
+const validation = validateAppPackRegistry();
+if (!validation.valid) {
+  throw new Error("Pack registry is invalid");
+}
+```
+
+Use shipped shaping contributions in tenant runtime code:
+
+```ts
+import { getShapingContribution } from "@lucern/pack-host/domain-pack";
+
+const shaping = getShapingContribution("engineering-accelerator");
+```
+
+## License
+
+UNLICENSED

package/dist/contracts.d.ts

@@ -0,0 +1,77 @@
+/**
+ * App Pack Contracts
+ *
+ * Canonical type contracts for Lucern app-pack manifests and runtime metadata.
+ */
+type PackLifecycle = "active" | "beta" | "experimental";
+type PackCategory = "conversation" | "research" | "graph" | "analytics" | "workflow" | "decision" | "news" | "documents" | "identity" | "operations" | "domain";
+type PackAudience = string;
+type PolicyAction = "read" | "summarize" | "export" | "mutate" | "admin";
+type PolicyResource = "project" | "node" | "edge" | "artifact" | "report_section" | "tool_action" | "task" | "user_profile" | "team_analytics";
+type ProjectionBehavior = "none" | "inherits_policy" | "projection_required";
+type PackRuntimeStage = "registered" | "validated" | "installed" | "enabled" | "degraded" | "disabled" | "removed";
+type SharedService = "decision-kernel" | "knowledge-compiler" | "learning-loop";
+type SharedServiceMode = "required" | "optional";
+type RouteNamespace = {
+    web: string[];
+    api: string[];
+};
+type SurfaceOwnership = {
+    components: string[];
+    convex: string[];
+    tools: string[];
+};
+type PolicyRule = {
+    resource: PolicyResource;
+    actions: PolicyAction[];
+    notes?: string;
+};
+type PolicyProfile = {
+    audiences: PackAudience[];
+    rules: PolicyRule[];
+};
+type DataContract = {
+    requiredNodeTypes: string[];
+    requiredEdgeTypes: string[];
+    requiredTables: string[];
+    projectionBehavior: ProjectionBehavior;
+};
+type TemplateAssets = {
+    workflows: string[];
+    prompts: string[];
+    reports: string[];
+    uiLabels: string[];
+};
+type PackTestSuite = {
+    parity: string[];
+    policy: string[];
+    contract: string[];
+};
+type SharedServiceIntegration = {
+    service: SharedService;
+    mode: SharedServiceMode;
+    contracts: string[];
+};
+type AppPackManifest = {
+    key: string;
+    name: string;
+    version: string;
+    lifecycle: PackLifecycle;
+    category: PackCategory;
+    description: string;
+    dependencies: string[];
+    capabilityFlags: string[];
+    routeNamespace: RouteNamespace;
+    surfaces: SurfaceOwnership;
+    policyProfile: PolicyProfile;
+    dataContract: DataContract;
+    templates: TemplateAssets;
+    testSuite: PackTestSuite;
+    sharedServices: SharedServiceIntegration[];
+};
+type AppPackManifestInput = Omit<AppPackManifest, "sharedServices"> & {
+    sharedServices?: SharedServiceIntegration[];
+};
+declare function defineAppPackManifest(manifest: AppPackManifestInput): AppPackManifest;
+
+export { type AppPackManifest, type DataContract, type PackAudience, type PackCategory, type PackLifecycle, type PackRuntimeStage, type PackTestSuite, type PolicyAction, type PolicyProfile, type PolicyResource, type PolicyRule, type ProjectionBehavior, type RouteNamespace, type SharedService, type SharedServiceIntegration, type SharedServiceMode, type SurfaceOwnership, type TemplateAssets, defineAppPackManifest };

package/dist/contracts.js

@@ -0,0 +1,21 @@
+// src/contracts.ts
+function normalizeStringArray(values) {
+  const normalized = values.map((value) => value.trim()).filter((value) => value.length > 0);
+  return Array.from(new Set(normalized));
+}
+function defineAppPackManifest(manifest) {
+  const sharedServices = (manifest.sharedServices ?? []).map((integration) => ({
+    ...integration,
+    contracts: normalizeStringArray(integration.contracts)
+  }));
+  return {
+    ...manifest,
+    dependencies: normalizeStringArray(manifest.dependencies),
+    capabilityFlags: normalizeStringArray(manifest.capabilityFlags),
+    sharedServices
+  };
+}
+
+export { defineAppPackManifest };
+//# sourceMappingURL=contracts.js.map
+//# sourceMappingURL=contracts.js.map

package/dist/contracts.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/contracts.ts"],"names":[],"mappings":";AA+HA,SAAS,qBAAqB,MAAA,EAA4B;AACxD,EAAA,MAAM,UAAA,GAAa,MAAA,CAChB,GAAA,CAAI,CAAC,UAAU,KAAA,CAAM,IAAA,EAAM,CAAA,CAC3B,MAAA,CAAO,CAAC,KAAA,KAAU,KAAA,CAAM,SAAS,CAAC,CAAA;AACrC,EAAA,OAAO,KAAA,CAAM,IAAA,CAAK,IAAI,GAAA,CAAI,UAAU,CAAC,CAAA;AACvC;AAEO,SAAS,sBACd,QAAA,EACiB;AACjB,EAAA,MAAM,kBAAkB,QAAA,CAAS,cAAA,IAAkB,EAAC,EAAG,GAAA,CAAI,CAAC,WAAA,MAAiB;AAAA,IAC3E,GAAG,WAAA;AAAA,IACH,SAAA,EAAW,oBAAA,CAAqB,WAAA,CAAY,SAAS;AAAA,GACvD,CAAE,CAAA;AAEF,EAAA,OAAO;AAAA,IACL,GAAG,QAAA;AAAA,IACH,YAAA,EAAc,oBAAA,CAAqB,QAAA,CAAS,YAAY,CAAA;AAAA,IACxD,eAAA,EAAiB,oBAAA,CAAqB,QAAA,CAAS,eAAe,CAAA;AAAA,IAC9D;AAAA,GACF;AACF","file":"contracts.js","sourcesContent":["/**\n * App Pack Contracts\n *\n * Canonical type contracts for Lucern app-pack manifests and runtime metadata.\n */\n\nexport type PackLifecycle = \"active\" | \"beta\" | \"experimental\";\n\nexport type PackCategory =\n  | \"conversation\"\n  | \"research\"\n  | \"graph\"\n  | \"analytics\"\n  | \"workflow\"\n  | \"decision\"\n  | \"news\"\n  | \"documents\"\n  | \"identity\"\n  | \"operations\"\n  | \"domain\";\n\nexport type PackAudience = string;\n\nexport type PolicyAction = \"read\" | \"summarize\" | \"export\" | \"mutate\" | \"admin\";\n\nexport type PolicyResource =\n  | \"project\"\n  | \"node\"\n  | \"edge\"\n  | \"artifact\"\n  | \"report_section\"\n  | \"tool_action\"\n  | \"task\"\n  | \"user_profile\"\n  | \"team_analytics\";\n\nexport type ProjectionBehavior =\n  | \"none\"\n  | \"inherits_policy\"\n  | \"projection_required\";\n\nexport type PackRuntimeStage =\n  | \"registered\"\n  | \"validated\"\n  | \"installed\"\n  | \"enabled\"\n  | \"degraded\"\n  | \"disabled\"\n  | \"removed\";\n\nexport type SharedService =\n  | \"decision-kernel\"\n  | \"knowledge-compiler\"\n  | \"learning-loop\";\n\nexport type SharedServiceMode = \"required\" | \"optional\";\n\nexport type RouteNamespace = {\n  web: string[];\n  api: string[];\n};\n\nexport type SurfaceOwnership = {\n  components: string[];\n  convex: string[];\n  tools: string[];\n};\n\nexport type PolicyRule = {\n  resource: PolicyResource;\n  actions: PolicyAction[];\n  notes?: string;\n};\n\nexport type PolicyProfile = {\n  audiences: PackAudience[];\n  rules: PolicyRule[];\n};\n\nexport type DataContract = {\n  requiredNodeTypes: string[];\n  requiredEdgeTypes: string[];\n  requiredTables: string[];\n  projectionBehavior: ProjectionBehavior;\n};\n\nexport type TemplateAssets = {\n  workflows: string[];\n  prompts: string[];\n  reports: string[];\n  uiLabels: string[];\n};\n\nexport type PackTestSuite = {\n  parity: string[];\n  policy: string[];\n  contract: string[];\n};\n\nexport type SharedServiceIntegration = {\n  service: SharedService;\n  mode: SharedServiceMode;\n  contracts: string[];\n};\n\nexport type AppPackManifest = {\n  key: string;\n  name: string;\n  version: string;\n  lifecycle: PackLifecycle;\n  category: PackCategory;\n  description: string;\n  dependencies: string[];\n  capabilityFlags: string[];\n  routeNamespace: RouteNamespace;\n  surfaces: SurfaceOwnership;\n  policyProfile: PolicyProfile;\n  dataContract: DataContract;\n  templates: TemplateAssets;\n  testSuite: PackTestSuite;\n  sharedServices: SharedServiceIntegration[];\n};\n\ntype AppPackManifestInput = Omit<AppPackManifest, \"sharedServices\"> & {\n  sharedServices?: SharedServiceIntegration[];\n};\n\nfunction normalizeStringArray(values: string[]): string[] {\n  const normalized = values\n    .map((value) => value.trim())\n    .filter((value) => value.length > 0);\n  return Array.from(new Set(normalized));\n}\n\nexport function defineAppPackManifest(\n  manifest: AppPackManifestInput\n): AppPackManifest {\n  const sharedServices = (manifest.sharedServices ?? []).map((integration) => ({\n    ...integration,\n    contracts: normalizeStringArray(integration.contracts),\n  }));\n\n  return {\n    ...manifest,\n    dependencies: normalizeStringArray(manifest.dependencies),\n    capabilityFlags: normalizeStringArray(manifest.capabilityFlags),\n    sharedServices,\n  };\n}\n"]}

package/dist/convex.config.d.ts

@@ -0,0 +1,5 @@
+import * as convex_server from 'convex/server';
+
+declare const component: convex_server.ComponentDefinition<any>;
+
+export { component as default };

package/dist/convex.config.js

@@ -0,0 +1,9 @@
+import { defineComponent } from 'convex/server';
+
+// convex.config.ts
+var component = defineComponent("pack-host");
+var convex_config_default = component;
+
+export { convex_config_default as default };
+//# sourceMappingURL=convex.config.js.map
+//# sourceMappingURL=convex.config.js.map

package/dist/convex.config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../convex.config.ts"],"names":[],"mappings":";;;AAEA,IAAM,SAAA,GAAY,gBAAgB,WAAW,CAAA;AAE7C,IAAO,qBAAA,GAAQ","file":"convex.config.js","sourcesContent":["import { defineComponent } from \"convex/server\";\n\nconst component = defineComponent(\"pack-host\");\n\nexport default component;\n"]}

package/dist/dependencyResolution.d.ts

@@ -0,0 +1,18 @@
+import { AppPackManifest } from './contracts.js';
+import { PackValidationIssue } from './manifestValidation.js';
+
+/**
+ * Pack Dependency Resolution
+ *
+ * Dependency-graph validation and deterministic activation ordering.
+ */
+
+type PackDependencyResolutionResult = {
+    orderedPackKeys: string[];
+    dependencyClosureByPack: Record<string, string[]>;
+    issues: PackValidationIssue[];
+    valid: boolean;
+};
+declare function resolvePackDependencyGraph(manifests: AppPackManifest[]): PackDependencyResolutionResult;
+
+export { type PackDependencyResolutionResult, resolvePackDependencyGraph };

package/dist/dependencyResolution.js

@@ -0,0 +1,131 @@
+// 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")
+  };
+}
+
+export { resolvePackDependencyGraph };
+//# sourceMappingURL=dependencyResolution.js.map
+//# sourceMappingURL=dependencyResolution.js.map

package/dist/dependencyResolution.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/dependencyResolution.ts"],"names":[],"mappings":"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","file":"dependencyResolution.js","sourcesContent":["/**\n * Pack Dependency Resolution\n *\n * Dependency-graph validation and deterministic activation ordering.\n */\n\nimport type { AppPackManifest } from \"./contracts\";\nimport type { PackValidationIssue } from \"./manifestValidation\";\n\nexport type PackDependencyResolutionResult = {\n  orderedPackKeys: string[];\n  dependencyClosureByPack: Record<string, string[]>;\n  issues: PackValidationIssue[];\n  valid: boolean;\n};\n\nfunction toIssue(\n  code: string,\n  message: string,\n  path: string,\n  severity: \"error\" | \"warning\" = \"error\"\n): PackValidationIssue {\n  return {\n    code,\n    severity,\n    message,\n    path,\n  };\n}\n\nfunction buildManifestMap(\n  manifests: AppPackManifest[]\n): Map<string, AppPackManifest> {\n  return new Map(manifests.map((manifest) => [manifest.key, manifest]));\n}\n\nfunction walkDependencyClosure(\n  manifestKey: string,\n  manifestsByKey: Map<string, AppPackManifest>,\n  path: string[],\n  closure: Set<string>,\n  issues: PackValidationIssue[]\n): void {\n  const manifest = manifestsByKey.get(manifestKey);\n  if (!manifest) {\n    return;\n  }\n\n  for (const dependency of manifest.dependencies) {\n    if (!manifestsByKey.has(dependency)) {\n      issues.push(\n        toIssue(\n          \"PACK_DEPENDENCY_MISSING\",\n          `Pack \"${manifestKey}\" depends on unknown pack \"${dependency}\".`,\n          `dependencies:${manifestKey}`\n        )\n      );\n      continue;\n    }\n\n    if (path.includes(dependency)) {\n      const cycle = [...path, dependency].join(\" -> \");\n      issues.push(\n        toIssue(\n          \"PACK_DEPENDENCY_CYCLE\",\n          `Cycle detected: ${cycle}`,\n          `dependencies:${manifestKey}`\n        )\n      );\n      continue;\n    }\n\n    if (closure.has(dependency)) {\n      continue;\n    }\n\n    closure.add(dependency);\n    walkDependencyClosure(\n      dependency,\n      manifestsByKey,\n      [...path, dependency],\n      closure,\n      issues\n    );\n  }\n}\n\nexport function resolvePackDependencyGraph(\n  manifests: AppPackManifest[]\n): PackDependencyResolutionResult {\n  const issues: PackValidationIssue[] = [];\n  const manifestsByKey = buildManifestMap(manifests);\n  const indegree = new Map<string, number>();\n  const adjacency = new Map<string, string[]>();\n\n  for (const manifest of manifests) {\n    indegree.set(manifest.key, indegree.get(manifest.key) ?? 0);\n    adjacency.set(manifest.key, []);\n  }\n\n  for (const manifest of manifests) {\n    for (const dependency of manifest.dependencies) {\n      if (!manifestsByKey.has(dependency)) {\n        issues.push(\n          toIssue(\n            \"PACK_DEPENDENCY_MISSING\",\n            `Pack \"${manifest.key}\" depends on unknown pack \"${dependency}\".`,\n            `dependencies:${manifest.key}`\n          )\n        );\n        continue;\n      }\n\n      const dependencyDependents = adjacency.get(dependency) ?? [];\n      dependencyDependents.push(manifest.key);\n      adjacency.set(dependency, dependencyDependents);\n\n      indegree.set(manifest.key, (indegree.get(manifest.key) ?? 0) + 1);\n    }\n  }\n\n  const queue = [...indegree.entries()]\n    .filter(([, value]) => value === 0)\n    .map(([packKey]) => packKey)\n    .sort();\n\n  const orderedPackKeys: string[] = [];\n  while (queue.length > 0) {\n    const nextKey = queue.shift();\n    if (!nextKey) {\n      break;\n    }\n\n    orderedPackKeys.push(nextKey);\n    const dependents = adjacency.get(nextKey) ?? [];\n    for (const dependent of dependents) {\n      const current = indegree.get(dependent) ?? 0;\n      const updated = current - 1;\n      indegree.set(dependent, updated);\n      if (updated === 0) {\n        queue.push(dependent);\n      }\n    }\n    queue.sort();\n  }\n\n  if (orderedPackKeys.length !== manifestsByKey.size) {\n    const unresolved = [...indegree.entries()]\n      .filter(([, value]) => value > 0)\n      .map(([key]) => key)\n      .sort();\n\n    issues.push(\n      toIssue(\n        \"PACK_DEPENDENCY_CYCLE\",\n        `Dependency graph is not acyclic; unresolved packs: ${unresolved.join(\", \")}`,\n        \"dependencies\"\n      )\n    );\n  }\n\n  const dependencyClosureByPack: Record<string, string[]> = {};\n  for (const manifest of manifests) {\n    const closure = new Set<string>();\n    walkDependencyClosure(\n      manifest.key,\n      manifestsByKey,\n      [manifest.key],\n      closure,\n      issues\n    );\n    dependencyClosureByPack[manifest.key] = [...closure].sort();\n  }\n\n  return {\n    orderedPackKeys,\n    dependencyClosureByPack,\n    issues,\n    valid: issues.every((issue) => issue.severity !== \"error\"),\n  };\n}\n"]}

package/dist/domain-pack/authoring.d.ts

@@ -0,0 +1,172 @@
+import { RuntimeTarget, DomainPack, DomainPackInput } from './contracts.js';
+import { DomainPackValidationIssue } from './validation.js';
+
+/**
+ * Domain Pack Authoring Kit
+ *
+ * Config-first authoring surface for tenant-authored domain packs. This layer
+ * wraps the internal DomainPack contract in a stable manifest envelope with
+ * framework versioning, schema and ontology extension contracts, remix/fork
+ * lineage, and tool-shaped validate/preview/publish handlers.
+ */
+
+declare const DOMAIN_PACK_MANIFEST_KIND: "lucern-domain-pack-manifest";
+declare const AUTHORING_TOOL_NAMES: {
+    readonly validate: "validate_domain_pack_manifest";
+    readonly preview: "preview_domain_pack_manifest";
+    readonly publish: "publish_domain_pack_manifest";
+};
+type DomainPackManifestFormat = "json" | "yaml";
+type DomainPackFrameworkContract = {
+    frameworkId: string;
+    version: string;
+    versionConstraint?: string;
+    required?: boolean;
+    runtimeTargets?: RuntimeTarget[];
+};
+type DomainPackSchemaExtensionTarget = "artifact" | "workflow" | "gate" | "prompt" | "tool" | "install-profile" | "topic-template";
+type DomainPackSchemaExtension = {
+    extensionId: string;
+    target: DomainPackSchemaExtensionTarget;
+    description: string;
+    version: string;
+    extends?: string;
+    schema: Record<string, unknown>;
+};
+type DomainPackOntologyEntityExtension = {
+    value: string;
+    label: string;
+    description?: string;
+    schema?: Record<string, unknown>;
+    subtypes?: string[];
+};
+type DomainPackOntologyEdgeExtension = {
+    value: string;
+    label: string;
+    description?: string;
+    sourceTypes?: string[];
+    targetTypes?: string[];
+    constraintSeverity?: "error" | "warning" | "informational";
+};
+type DomainPackOntologyExtension = {
+    extensionId: string;
+    ontologyId: string;
+    baseVersionConstraint: string;
+    additiveOnly: boolean;
+    entityTypes?: DomainPackOntologyEntityExtension[];
+    edgeTypes?: DomainPackOntologyEdgeExtension[];
+};
+type DomainPackLineageMode = "root" | "remix" | "fork";
+type DomainPackLineage = {
+    mode: DomainPackLineageMode;
+    parentPackId?: string;
+    parentVersion?: string;
+    parentManifestDigest?: string;
+    supersedesPackId?: string;
+    notes?: string;
+};
+type DomainPackAuthoringMetadata = {
+    description?: string;
+    owner?: string;
+    tags?: string[];
+};
+type DomainPackAuthoringManifest = {
+    kind: typeof DOMAIN_PACK_MANIFEST_KIND;
+    manifestVersion: string;
+    pack: DomainPack;
+    frameworks?: DomainPackFrameworkContract[];
+    schemaExtensions?: DomainPackSchemaExtension[];
+    ontologyExtensions?: DomainPackOntologyExtension[];
+    lineage: DomainPackLineage;
+    metadata?: DomainPackAuthoringMetadata;
+};
+type DomainPackAuthoringManifestInput = {
+    kind?: typeof DOMAIN_PACK_MANIFEST_KIND;
+    manifestVersion?: string;
+    pack: DomainPack | DomainPackInput;
+    frameworks?: DomainPackFrameworkContract[];
+    schemaExtensions?: DomainPackSchemaExtension[];
+    ontologyExtensions?: DomainPackOntologyExtension[];
+    lineage?: DomainPackLineage;
+    metadata?: DomainPackAuthoringMetadata;
+};
+type DomainPackAuthoringValidationIssue = DomainPackValidationIssue & {
+    source: "manifest" | "pack" | "framework" | "schema-extension" | "ontology-extension" | "lineage" | "terminology" | "parse";
+};
+type DomainPackManifestCounts = {
+    topicRoots: number;
+    workflows: number;
+    gates: number;
+    artifacts: number;
+    roles: number;
+    prompts: number;
+    tools: number;
+    setupAssets: number;
+    installProfiles: number;
+    frameworks: number;
+    schemaExtensions: number;
+    ontologyExtensions: number;
+};
+type DomainPackAuthoringValidationResult = {
+    valid: boolean;
+    format: DomainPackManifestFormat | null;
+    manifest: DomainPackAuthoringManifest | null;
+    manifestDigest: string | null;
+    issues: DomainPackAuthoringValidationIssue[];
+    counts: DomainPackManifestCounts;
+};
+type DomainPackAuthoringPreview = DomainPackAuthoringValidationResult & {
+    readyToPublish: boolean;
+    canonicalJson: string | null;
+    canonicalYaml: string | null;
+    lineageSummary: string | null;
+    requiredRuntimeTargets: RuntimeTarget[];
+};
+type DomainPackPublicationLineageEdge = {
+    edgeType: "remixed_from" | "supersedes";
+    childPackId: string;
+    parentPackId: string;
+    parentVersion: string;
+};
+type DomainPackPublication = {
+    publicationId: string;
+    packId: string;
+    version: string;
+    manifestDigest: string;
+    manifest: DomainPackAuthoringManifest;
+    lineageEdge: DomainPackPublicationLineageEdge | null;
+    canonicalJson: string;
+    canonicalYaml: string;
+};
+type DomainPackPublishResult = {
+    published: boolean;
+    preview: DomainPackAuthoringPreview;
+    publication: DomainPackPublication | null;
+};
+type DomainPackAuthoringToolInput = {
+    manifestText: string;
+    format?: DomainPackManifestFormat;
+};
+type DomainPackAuthoringToolDefinition<Result> = {
+    name: typeof AUTHORING_TOOL_NAMES.validate | typeof AUTHORING_TOOL_NAMES.preview | typeof AUTHORING_TOOL_NAMES.publish;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    execute: (args: DomainPackAuthoringToolInput) => Result;
+};
+type DomainPackAuthoringToolset = {
+    validate: DomainPackAuthoringToolDefinition<DomainPackAuthoringValidationResult>;
+    preview: DomainPackAuthoringToolDefinition<DomainPackAuthoringPreview>;
+    publish: DomainPackAuthoringToolDefinition<DomainPackPublishResult>;
+};
+declare function defineDomainPackAuthoringManifest(input: DomainPackAuthoringManifestInput): DomainPackAuthoringManifest;
+declare function serializeDomainPackAuthoringManifest(manifest: DomainPackAuthoringManifest, format?: DomainPackManifestFormat): string;
+declare function parseDomainPackAuthoringManifest(source: string, format?: DomainPackManifestFormat): DomainPackAuthoringManifest;
+declare function validateDomainPackAuthoringManifest(manifest: DomainPackAuthoringManifest | DomainPackAuthoringManifestInput): DomainPackAuthoringValidationResult;
+declare function validateDomainPackAuthoringManifestSource(source: string, format?: DomainPackManifestFormat): DomainPackAuthoringValidationResult;
+declare function previewDomainPackAuthoringManifest(manifest: DomainPackAuthoringManifest | DomainPackAuthoringManifestInput): DomainPackAuthoringPreview;
+declare function previewDomainPackAuthoringManifestSource(source: string, format?: DomainPackManifestFormat): DomainPackAuthoringPreview;
+declare function publishDomainPackAuthoringManifest(manifest: DomainPackAuthoringManifest | DomainPackAuthoringManifestInput): DomainPackPublishResult;
+declare function publishDomainPackAuthoringManifestSource(source: string, format?: DomainPackManifestFormat): DomainPackPublishResult;
+declare function createDomainPackAuthoringTools(): DomainPackAuthoringToolset;
+
+export { type DomainPackAuthoringManifest, type DomainPackAuthoringManifestInput, type DomainPackAuthoringMetadata, type DomainPackAuthoringPreview, type DomainPackAuthoringToolDefinition, type DomainPackAuthoringToolInput, type DomainPackAuthoringToolset, type DomainPackAuthoringValidationIssue, type DomainPackAuthoringValidationResult, type DomainPackFrameworkContract, type DomainPackLineage, type DomainPackLineageMode, type DomainPackManifestCounts, type DomainPackManifestFormat, type DomainPackOntologyEdgeExtension, type DomainPackOntologyEntityExtension, type DomainPackOntologyExtension, type DomainPackPublication, type DomainPackPublicationLineageEdge, type DomainPackPublishResult, type DomainPackSchemaExtension, type DomainPackSchemaExtensionTarget, createDomainPackAuthoringTools, defineDomainPackAuthoringManifest, parseDomainPackAuthoringManifest, previewDomainPackAuthoringManifest, previewDomainPackAuthoringManifestSource, publishDomainPackAuthoringManifest, publishDomainPackAuthoringManifestSource, serializeDomainPackAuthoringManifest, validateDomainPackAuthoringManifest, validateDomainPackAuthoringManifestSource };