arkgate 2.12.0 → 2.13.0

package/dist/nestjs/index.cjs

@@ -1671,6 +1671,138 @@ function createIntentRegistry() {
   return new IntentRegistry();
 }
 
+// src/domain/configContract.ts
+var ARK_CONFIG_SCHEMA_VERSION = "1.0";
+var ARK_CONFIG_SCHEMA_URL = "https://unpkg.com/arkgate@2/schemas/ark.config.schema.json";
+var DEFAULT_LAYER_NAMES = [
+  "DomainModel",
+  "ApplicationOrchestration",
+  "PersistenceAdapters",
+  "IntegrationAdapters",
+  "WorkflowSagaEngine",
+  "BackgroundJobsScheduling",
+  "PresentationAdapters",
+  "ReportingReadModels",
+  "ExtensibilityMetadata",
+  "SecurityAuditObservability",
+  "Kernel"
+];
+var DEFAULT_ALLOWED_FLOWS = /* @__PURE__ */ new Set([
+  "PresentationAdapters->ApplicationOrchestration",
+  "ApplicationOrchestration->DomainModel",
+  "WorkflowSagaEngine->ApplicationOrchestration",
+  "WorkflowSagaEngine->DomainModel",
+  "BackgroundJobsScheduling->ApplicationOrchestration"
+]);
+function createDefaultRules() {
+  const rules = [];
+  for (const from of DEFAULT_LAYER_NAMES) {
+    for (const to of DEFAULT_LAYER_NAMES) {
+      if (from === to || DEFAULT_ALLOWED_FLOWS.has(`${from}->${to}`)) continue;
+      rules.push({ from, to, allowed: false });
+    }
+  }
+  return rules;
+}
+var DEFAULT_ARK_CONFIG_RULES = createDefaultRules();
+var stringArraySchema = {
+  type: "array",
+  items: { type: "string", minLength: 1 },
+  uniqueItems: true
+};
+var ARK_CONFIG_SCHEMA = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: ARK_CONFIG_SCHEMA_URL,
+  title: "ArkGate architecture contract",
+  description: "Versioned contract consumed identically by ArkGate CLI, MCP, and ESLint surfaces.",
+  type: "object",
+  additionalProperties: false,
+  required: ["$schema", "schemaVersion", "include", "layers", "rules"],
+  properties: {
+    $schema: {
+      type: "string",
+      minLength: 1,
+      default: ARK_CONFIG_SCHEMA_URL,
+      description: "Editor-facing URL or local path for this JSON Schema."
+    },
+    schemaVersion: {
+      type: "string",
+      const: ARK_CONFIG_SCHEMA_VERSION,
+      default: ARK_CONFIG_SCHEMA_VERSION
+    },
+    name: { type: "string", minLength: 1 },
+    include: { ...stringArraySchema, minItems: 1, default: ["src"] },
+    exclude: { ...stringArraySchema, default: [] },
+    excludeGenerated: { type: "boolean", default: true },
+    frameworkOverlay: { type: "string", minLength: 1 },
+    layers: {
+      type: "array",
+      default: [],
+      items: { $ref: "#/$defs/layer" }
+    },
+    rules: {
+      type: "array",
+      default: DEFAULT_ARK_CONFIG_RULES,
+      items: { $ref: "#/$defs/rule" }
+    },
+    cyclePolicy: {
+      type: "string",
+      enum: ["strict", "soft", "framework-soft", "off"],
+      default: "strict"
+    },
+    dynamicImportAllowlist: { ...stringArraySchema, default: [] },
+    safety: {
+      $ref: "#/$defs/safety",
+      default: {
+        maxTsSuppressions: 0,
+        maxAnyCasts: 0,
+        allowInMemory: false,
+        allowDisabledPeerIsolation: false
+      }
+    }
+  },
+  $defs: {
+    layer: {
+      type: "object",
+      additionalProperties: false,
+      required: ["name", "patterns"],
+      properties: {
+        name: { type: "string", minLength: 1 },
+        patterns: { ...stringArraySchema, minItems: 1 },
+        exclude: stringArraySchema,
+        intentPrefixes: stringArraySchema,
+        description: { type: "string", minLength: 1 },
+        forbiddenGlobals: stringArraySchema,
+        mayImportInfrastructure: { type: "boolean" },
+        optional: { type: "boolean" }
+      }
+    },
+    rule: {
+      type: "object",
+      additionalProperties: false,
+      required: ["from", "to", "allowed"],
+      properties: {
+        from: { type: "string", minLength: 1 },
+        to: { type: "string", minLength: 1 },
+        allowed: { type: "boolean" },
+        message: { type: "string", minLength: 1 },
+        peerIsolation: { type: "boolean" },
+        sliceFolders: { ...stringArraySchema, minItems: 1 }
+      }
+    },
+    safety: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        maxTsSuppressions: { type: "integer", minimum: 0, default: 0 },
+        maxAnyCasts: { type: "integer", minimum: 0, default: 0 },
+        allowInMemory: { type: "boolean", default: false },
+        allowDisabledPeerIsolation: { type: "boolean", default: false }
+      }
+    }
+  }
+};
+
 // src/kernel/layers/ArchitectureProfile.ts
 function normalizePrefix(prefix) {
   return prefix.endsWith(".") ? prefix : `${prefix}.`;
@@ -1680,21 +1812,6 @@ function byLongestPrefix(a, b) {
   const maxB = b.prefixes.length ? Math.max(...b.prefixes.map((p) => p.length)) : 0;
   return maxB - maxA;
 }
-function flowKey(from, to) {
-  return `${from}->${to}`;
-}
-function createStrictDenyRules(layers, allowedFlows) {
-  const allowed = new Set(allowedFlows.map((flow) => flowKey(flow.from, flow.to)));
-  const rules = [];
-  for (const from of layers) {
-    for (const to of layers) {
-      if (from.name === to.name) continue;
-      if (allowed.has(flowKey(from.name, to.name))) continue;
-      rules.push({ from: from.name, to: to.name, allowed: false });
-    }
-  }
-  return rules;
-}
 function createArchitectureProfile(options) {
   const layers = options.layers.map((layer) => ({
     ...layer,
@@ -1781,27 +1898,17 @@ var elevenLayerProfileLayers = [
     order: 11
   }
 ];
-var elevenLayerAllowedFlows = [
-  { from: "PresentationAdapters", to: "ApplicationOrchestration" },
-  { from: "ApplicationOrchestration", to: "DomainModel" },
-  { from: "WorkflowSagaEngine", to: "ApplicationOrchestration" },
-  { from: "WorkflowSagaEngine", to: "DomainModel" },
-  { from: "BackgroundJobsScheduling", to: "ApplicationOrchestration" }
-];
 var elevenLayerProfile = createArchitectureProfile({
   name: "Ark 11-layer Hexagonal Event-Driven Profile",
   layers: elevenLayerProfileLayers,
-  rules: createStrictDenyRules(
-    elevenLayerProfileLayers,
-    elevenLayerAllowedFlows
-  )
+  rules: DEFAULT_ARK_CONFIG_RULES.map((rule) => ({ ...rule }))
 });
 
 // src/kernel/manifest/constants.ts
 var MANIFEST_SCHEMA_VERSION = "1.0";
 
 // src/version.ts
-var version = "2.12.0";
+var version = "2.13.0";
 
 // src/kernel/manifest/createArkManifest.ts
 function policyId(name) {
@@ -1937,14 +2044,14 @@ function createMetadataRegistry() {
 }
 
 // src/kernel/observability/ObservabilityReporter.ts
-function flowKey2(flow) {
+function flowKey(flow) {
   return `${flow.from}->${flow.to}`;
 }
 function uniqueFlows(flows) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
   for (const flow of flows) {
-    const key = flowKey2(flow);
+    const key = flowKey(flow);
     if (seen.has(key)) continue;
     seen.add(key);
     result.push(flow);
@@ -1952,8 +2059,8 @@ function uniqueFlows(flows) {
   return result;
 }
 function difference(left, right) {
-  const rightKeys = new Set(right.map(flowKey2));
-  return left.filter((flow) => !rightKeys.has(flowKey2(flow)));
+  const rightKeys = new Set(right.map(flowKey));
+  return left.filter((flow) => !rightKeys.has(flowKey(flow)));
 }
 function createObservabilityReporter(options) {
   const registry = options.registry;
@@ -2298,22 +2405,13 @@ var WorkflowEngineImpl = class {
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
       snapshot.attempts[step.name] = attempt;
       await this.store.save(snapshot);
+      let result;
       try {
-        const result = await withTimeout(
+        result = await withTimeout(
           (signal) => Promise.resolve(step.execute(snapshot.context, this.bus, signal)),
           step.timeoutMs,
           step.name
         );
-        if (result) Object.assign(snapshot.context, result);
-        snapshot.completedSteps.push(step.name);
-        snapshot.currentStep = void 0;
-        snapshot.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-        await this.store.save(snapshot);
-        await this.audit("workflow.step.completed", snapshot, {
-          step: step.name,
-          attempt
-        });
-        return;
       } catch (err) {
         if (attempt < maxAttempts) {
           if (retry.delayMs) await sleep(retry.delayMs);
@@ -2329,6 +2427,16 @@ var WorkflowEngineImpl = class {
         });
         throw err;
       }
+      if (result) Object.assign(snapshot.context, result);
+      snapshot.completedSteps.push(step.name);
+      snapshot.currentStep = void 0;
+      snapshot.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.store.save(snapshot);
+      await this.audit("workflow.step.completed", snapshot, {
+        step: step.name,
+        attempt
+      });
+      return;
     }
     throw new Error(`Workflow step "${step.name}" did not complete.`);
   }