@kortexya/reasoninglayer 1.3.0 → 1.4.0

package/dist/index.cjs

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "1.3.0";
+var SDK_VERSION = "1.4.0";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -9070,6 +9070,7 @@ var TAGGED_VALUE_TYPES = /* @__PURE__ */ new Set([
   "Boolean",
   "Uninstantiated",
   "Reference",
+  "SortId",
   "List",
   "FuzzyScalar",
   "FuzzyNumber",
@@ -9165,6 +9166,12 @@ function toUntaggedValue(value) {
     };
   }
   if (isTaggedValueDto(value)) {
+    if (value.type === "Reference") {
+      return { termId: value.value };
+    }
+    if (value.type === "SortId") {
+      return { sortRef: value.value };
+    }
     return value;
   }
   return value;
@@ -9577,6 +9584,9 @@ function FeatureInputValueDtoFromFrontToApi(value) {
       ...features ? { features } : {}
     };
   }
+  if ("sortRef" in value) {
+    return { sort_ref: value.sortRef };
+  }
   return { term_id: value.termId };
 }
 function featuresInputFromFrontToApi(features) {
@@ -20837,7 +20847,12 @@ var OptimizeClient = class {
         sorts: [{ name: solutionSortName, parents: ["thing"] }]
       });
       const sortIdsMap = sortResponse.data.sort_ids;
-      sortId = Object.values(sortIdsMap)[0];
+      sortId = sortIdsMap[solutionSortName];
+      if (!sortId) {
+        throw new Error(
+          `bulkCreateSorts did not return an id for '${solutionSortName}' (returned: ${Object.keys(sortIdsMap).join(", ")})`
+        );
+      }
       const ruleResponse = await this.inferenceApi.addRule({
         term: TermInputDtoFromFrontToApi(compiled.solutionTerm),
         antecedents: compiled.antecedents.map(TermInputDtoFromFrontToApi),
@@ -23216,6 +23231,26 @@ var Value = {
   reference(id) {
     return { type: "Reference", value: id };
   },
+  /**
+   * Create a reference to a sort by UUID.
+   *
+   * @param id - The UUID of the sort.
+   * @returns A tagged `SortIdValue`: `{"type": "SortId", "value": "uuid"}`.
+   *
+   * @remarks
+   * Used by homoiconic meta-constraints — primarily `Constraint.typeOf(...)`
+   * — whose feature targets a sort as a first-class value. The chainer
+   * dispatches this directly via `Value::SortId`.
+   *
+   * @example
+   * ```typescript
+   * Value.sortId("550e8400-e29b-41d4-a716-446655440000")
+   * // { type: 'SortId', value: '550e8400-e29b-41d4-a716-446655440000' }
+   * ```
+   */
+  sortId(id) {
+    return { type: "SortId", value: id };
+  },
   /**
    * Create a fuzzy scalar with a value and membership degree.
    *
@@ -23633,6 +23668,145 @@ var FuzzyShape = {
   }
 };
 
+// src/builders/psi.ts
+function psi(sortOrName, features) {
+  if (typeof sortOrName === "string") {
+    if (!features) {
+      return { __psiTerm: true, sortName: sortOrName };
+    }
+    return {
+      __psiTerm: true,
+      sortName: sortOrName,
+      features
+    };
+  }
+  if (!features) {
+    return { __psiTerm: true, sortId: sortOrName.sortId };
+  }
+  return {
+    __psiTerm: true,
+    sortId: sortOrName.sortId,
+    features
+  };
+}
+function constrained(name, constraint) {
+  return { __constrainedVar: true, name, constraint };
+}
+
+// src/builders/constraint.ts
+var ARITHMETIC_SORT = {
+  "+": "plus_constraint",
+  "-": "minus_constraint",
+  "*": "times_constraint",
+  "/": "div_constraint"
+};
+var Constraint = {
+  /**
+   * State that a variable is a term of a given sort. The chainer enumerates
+   * every persisted term of that sort via backtracking.
+   *
+   * @param variable - Variable name (e.g. `'?E'`) or pre-built variable Ψ-term.
+   * @param sortUuid - UUID of the target sort (resolve from
+   *   `client.inference.getMetaSorts()` or your own `createSort` response).
+   * @returns A `sort_constraint` term.
+   */
+  typeOf(variable, sortUuid) {
+    return psi("sort_constraint", {
+      var: variable,
+      sort: { sortRef: sortUuid }
+    });
+  },
+  /**
+   * State that a variable's feature equals a target. The chainer unifies
+   * the variable's feature value with the target.
+   *
+   * **Important**: the chainer's `feature_constraint` only unifies
+   * term-references with term-references. The variable's feature on the
+   * persisted side must itself be a `Value::Reference`. Comparing against
+   * literals (e.g. `has('?N', 'name', 'S')` where `name` is stored as a
+   * plain string) silently returns zero solutions — that's a chainer
+   * design constraint, not a builder bug.
+   *
+   * @param variable - The owning variable (e.g. `'?Edge'`).
+   * @param feature - The feature name (e.g. `'src'`).
+   * @param target - The target — typically another variable (`'?Src'`)
+   *   or an existing term referenced by its UUID via `'!<uuid>'`.
+   * @returns A `feature_constraint` term.
+   */
+  has(variable, feature, target) {
+    return psi("feature_constraint", {
+      var: variable,
+      feature,
+      target
+    });
+  },
+  /**
+   * State a boolean comparison between two operands. The chainer
+   * residuates the constraint until both sides are bound; when they are,
+   * the comparison must hold or the proof branch fails.
+   *
+   * @param left - Left operand — variable, literal number, or term ref.
+   * @param op - Comparison operator.
+   * @param right - Right operand.
+   * @returns A `guard_constraint` term.
+   */
+  where(left, op, right) {
+    return psi("guard_constraint", {
+      left,
+      operator: op,
+      right
+    });
+  },
+  /**
+   * State that `result = left op right`. Selects the chainer sort by op:
+   * `+` → `plus_constraint`, `-` → `minus_constraint`, `*` →
+   * `times_constraint`, `/` → `div_constraint`. The chainer reads each
+   * operand as either a Reference variable or a numeric literal, and can
+   * run forward, reverse, or verify depending on which operands are
+   * bound.
+   *
+   * @param result - Result variable or value (`z`).
+   * @param op - Arithmetic operator.
+   * @param left - Left operand (`x`).
+   * @param right - Right operand (`y`).
+   * @returns The appropriate arithmetic-constraint term.
+   */
+  equation(result, op, left, right) {
+    return psi(ARITHMETIC_SORT[op], { x: left, y: right, z: result });
+  },
+  /**
+   * Constrain a variable to be an integer in the inclusive range
+   * `[min, max]`. Required before the chainer's labeling step can assign
+   * a concrete value via {@link Constraint.solveFor}.
+   *
+   * @param variable - Variable name to constrain.
+   * @param min - Lower bound (inclusive).
+   * @param max - Upper bound (inclusive).
+   * @returns An `fd_domain_constraint` term.
+   */
+  intRange(variable, min, max) {
+    return psi("fd_domain_constraint", {
+      var: variable,
+      min,
+      max
+    });
+  },
+  /**
+   * Search for concrete integer assignments to the listed variables that
+   * satisfy every other constraint mentioning them. Place this at the END
+   * of a clause body — it's the labeling/search step that turns a
+   * constraint network into solutions.
+   *
+   * @param variables - Variable names to assign.
+   * @returns An `fd_labeling_constraint` term.
+   */
+  solveFor(...variables) {
+    return psi("fd_labeling_constraint", {
+      vars: variables
+    });
+  }
+};
+
 // src/builders/guard.ts
 function guard(op, right) {
   return {
@@ -23810,31 +23984,6 @@ var SortBuilder = class _SortBuilder {
   }
 };
 
-// src/builders/psi.ts
-function psi(sortOrName, features) {
-  if (typeof sortOrName === "string") {
-    if (!features) {
-      return { __psiTerm: true, sortName: sortOrName };
-    }
-    return {
-      __psiTerm: true,
-      sortName: sortOrName,
-      features
-    };
-  }
-  if (!features) {
-    return { __psiTerm: true, sortId: sortOrName.sortId };
-  }
-  return {
-    __psiTerm: true,
-    sortId: sortOrName.sortId,
-    features
-  };
-}
-function constrained(name, constraint) {
-  return { __constrainedVar: true, name, constraint };
-}
-
 // src/builders/allen.ts
 function allen(relation, intervalA, intervalBTermId) {
   return {
@@ -24107,6 +24256,7 @@ exports.Cognitive = cognitive_exports;
 exports.Collections = collections_exports;
 exports.Communities = communities_exports;
 exports.Compliance = compliance_exports;
+exports.Constraint = Constraint;
 exports.ConstraintViolationError = ConstraintViolationError;
 exports.Constraints = constraints_exports;
 exports.Control = control_exports;