@proposit/proposit-core 0.8.9

package/dist/lib/core/evaluation/kleene.js

@@ -0,0 +1,29 @@
+/** Kleene three-valued NOT: null propagates. */
+export function kleeneNot(a) {
+    return a === null ? null : !a;
+}
+/** Kleene three-valued AND: false dominates, null propagates. */
+export function kleeneAnd(a, b) {
+    if (a === false || b === false)
+        return false;
+    if (a === null || b === null)
+        return null;
+    return true;
+}
+/** Kleene three-valued OR: true dominates, null propagates. */
+export function kleeneOr(a, b) {
+    if (a === true || b === true)
+        return true;
+    if (a === null || b === null)
+        return null;
+    return false;
+}
+/** Kleene three-valued material implication: NOT a OR b. */
+export function kleeneImplies(a, b) {
+    return kleeneOr(kleeneNot(a), b);
+}
+/** Kleene three-valued biconditional: (a -> b) AND (b -> a). */
+export function kleeneIff(a, b) {
+    return kleeneAnd(kleeneImplies(a, b), kleeneImplies(b, a));
+}
+//# sourceMappingURL=kleene.js.map

package/dist/lib/core/evaluation/kleene.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kleene.js","sourceRoot":"","sources":["../../../../src/lib/core/evaluation/kleene.ts"],"names":[],"mappings":"AAEA,gDAAgD;AAChD,MAAM,UAAU,SAAS,CAAC,CAAsB;IAC5C,OAAO,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;AACjC,CAAC;AAED,iEAAiE;AACjE,MAAM,UAAU,SAAS,CACrB,CAAsB,EACtB,CAAsB;IAEtB,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,KAAK;QAAE,OAAO,KAAK,CAAA;IAC5C,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,IAAI;QAAE,OAAO,IAAI,CAAA;IACzC,OAAO,IAAI,CAAA;AACf,CAAC;AAED,+DAA+D;AAC/D,MAAM,UAAU,QAAQ,CACpB,CAAsB,EACtB,CAAsB;IAEtB,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,IAAI;QAAE,OAAO,IAAI,CAAA;IACzC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,IAAI;QAAE,OAAO,IAAI,CAAA;IACzC,OAAO,KAAK,CAAA;AAChB,CAAC;AAED,4DAA4D;AAC5D,MAAM,UAAU,aAAa,CACzB,CAAsB,EACtB,CAAsB;IAEtB,OAAO,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;AACpC,CAAC;AAED,gEAAgE;AAChE,MAAM,UAAU,SAAS,CACrB,CAAsB,EACtB,CAAsB;IAEtB,OAAO,SAAS,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;AAC9D,CAAC"}

package/dist/lib/core/evaluation/validation.d.ts

@@ -0,0 +1,10 @@
+import type { TCoreDirectionalVacuity, TCoreTrivalentValue, TCoreValidationIssue, TCoreValidationResult } from "../../types/evaluation.js";
+/** Creates a validation result, setting `ok` based on whether any error-severity issues exist. */
+export declare function makeValidationResult(issues: TCoreValidationIssue[]): TCoreValidationResult;
+/** Creates a validation issue with `severity: "error"`. */
+export declare function makeErrorIssue(issue: Omit<TCoreValidationIssue, "severity">): TCoreValidationIssue;
+/** Computes Kleene three-valued material implication: `!antecedent || consequent`. */
+export declare function implicationValue(antecedent: TCoreTrivalentValue, consequent: TCoreTrivalentValue): TCoreTrivalentValue;
+/** Builds a directional vacuity diagnostic for one direction of an implication. */
+export declare function buildDirectionalVacuity(antecedentTrue: TCoreTrivalentValue, consequentTrue: TCoreTrivalentValue): TCoreDirectionalVacuity;
+//# sourceMappingURL=validation.d.ts.map

package/dist/lib/core/evaluation/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../src/lib/core/evaluation/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,uBAAuB,EACvB,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACxB,MAAM,2BAA2B,CAAA;AAGlC,kGAAkG;AAClG,wBAAgB,oBAAoB,CAChC,MAAM,EAAE,oBAAoB,EAAE,GAC/B,qBAAqB,CAKvB;AAED,2DAA2D;AAC3D,wBAAgB,cAAc,CAC1B,KAAK,EAAE,IAAI,CAAC,oBAAoB,EAAE,UAAU,CAAC,GAC9C,oBAAoB,CAEtB;AAED,sFAAsF;AACtF,wBAAgB,gBAAgB,CAC5B,UAAU,EAAE,mBAAmB,EAC/B,UAAU,EAAE,mBAAmB,GAChC,mBAAmB,CAErB;AAED,mFAAmF;AACnF,wBAAgB,uBAAuB,CACnC,cAAc,EAAE,mBAAmB,EACnC,cAAc,EAAE,mBAAmB,GACpC,uBAAuB,CASzB"}

package/dist/lib/core/evaluation/validation.js

@@ -0,0 +1,28 @@
+import { kleeneAnd, kleeneImplies, kleeneNot } from "./kleene.js";
+/** Creates a validation result, setting `ok` based on whether any error-severity issues exist. */
+export function makeValidationResult(issues) {
+    return {
+        ok: issues.every((issue) => issue.severity !== "error"),
+        issues,
+    };
+}
+/** Creates a validation issue with `severity: "error"`. */
+export function makeErrorIssue(issue) {
+    return { severity: "error", ...issue };
+}
+/** Computes Kleene three-valued material implication: `!antecedent || consequent`. */
+export function implicationValue(antecedent, consequent) {
+    return kleeneImplies(antecedent, consequent);
+}
+/** Builds a directional vacuity diagnostic for one direction of an implication. */
+export function buildDirectionalVacuity(antecedentTrue, consequentTrue) {
+    const implication = implicationValue(antecedentTrue, consequentTrue);
+    return {
+        antecedentTrue,
+        consequentTrue,
+        implicationValue: implication,
+        isVacuouslyTrue: kleeneAnd(implication, kleeneNot(antecedentTrue)),
+        fired: antecedentTrue,
+    };
+}
+//# sourceMappingURL=validation.js.map

package/dist/lib/core/evaluation/validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.js","sourceRoot":"","sources":["../../../../src/lib/core/evaluation/validation.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEjE,kGAAkG;AAClG,MAAM,UAAU,oBAAoB,CAChC,MAA8B;IAE9B,OAAO;QACH,EAAE,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,KAAK,OAAO,CAAC;QACvD,MAAM;KACT,CAAA;AACL,CAAC;AAED,2DAA2D;AAC3D,MAAM,UAAU,cAAc,CAC1B,KAA6C;IAE7C,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,KAAK,EAAE,CAAA;AAC1C,CAAC;AAED,sFAAsF;AACtF,MAAM,UAAU,gBAAgB,CAC5B,UAA+B,EAC/B,UAA+B;IAE/B,OAAO,aAAa,CAAC,UAAU,EAAE,UAAU,CAAC,CAAA;AAChD,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,uBAAuB,CACnC,cAAmC,EACnC,cAAmC;IAEnC,MAAM,WAAW,GAAG,gBAAgB,CAAC,cAAc,EAAE,cAAc,CAAC,CAAA;IACpE,OAAO;QACH,cAAc;QACd,cAAc;QACd,gBAAgB,EAAE,WAAW;QAC7B,eAAe,EAAE,SAAS,CAAC,WAAW,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC;QAClE,KAAK,EAAE,cAAc;KACxB,CAAA;AACL,CAAC"}

package/dist/lib/core/expression-manager.d.ts

@@ -0,0 +1,278 @@
+import type { TCoreLogicalOperatorType, TCorePropositionalExpression } from "../schemata/index.js";
+import type { ChangeCollector } from "./change-collector.js";
+import type { TLogicEngineOptions } from "./argument-engine.js";
+import { type TGrammarConfig } from "../types/grammar.js";
+import type { TInvariantValidationResult } from "../types/validation.js";
+export type TExpressionInput<TExpr extends TCorePropositionalExpression = TCorePropositionalExpression> = TExpr extends infer U ? U extends TCorePropositionalExpression ? Omit<U, "checksum" | "descendantChecksum" | "combinedChecksum"> : never : never;
+export type TExpressionWithoutPosition<TExpr extends TCorePropositionalExpression = TCorePropositionalExpression> = TExpr extends infer U ? U extends TCorePropositionalExpression ? Omit<U, "position" | "checksum" | "descendantChecksum" | "combinedChecksum"> : never : never;
+export type TExpressionManagerSnapshot<TExpr extends TCorePropositionalExpression = TCorePropositionalExpression> = {
+    expressions: TExpr[];
+    config?: TLogicEngineOptions;
+};
+/** Fields that may be updated on an existing expression. */
+export type TExpressionUpdate = {
+    position?: number;
+    variableId?: string;
+    operator?: TCoreLogicalOperatorType;
+};
+/**
+ * Low-level manager for a flat-stored expression tree.
+ *
+ * Expressions are immutable value objects stored in three maps: the main
+ * expression store, a parent-to-children ID index, and a parent-to-positions
+ * index. Structural invariants (child limits, root-only operators, position
+ * uniqueness) are enforced on every mutation.
+ *
+ * This class is an internal building block used by {@link PremiseEngine}
+ * and is not part of the public API.
+ */
+export declare class ExpressionManager<TExpr extends TCorePropositionalExpression = TCorePropositionalExpression> {
+    private expressions;
+    private childExpressionIdsByParentId;
+    private childPositionsByParentId;
+    private positionConfig;
+    private config?;
+    private generateId;
+    private collector;
+    private dirtyExpressionIds;
+    setCollector(collector: ChangeCollector | null): void;
+    constructor(config?: TLogicEngineOptions);
+    private get grammarConfig();
+    private attachChecksum;
+    /**
+     * Creates and registers a formula-buffer expression in the three internal
+     * maps (`expressions`, `childExpressionIdsByParentId`,
+     * `childPositionsByParentId`) and notifies the change collector.
+     *
+     * Used by `addExpression`, `insertExpression`, and `wrapExpression` to
+     * auto-insert formula nodes between operators when
+     * `grammarConfig.autoNormalize` is enabled.
+     *
+     * @returns The generated formula expression ID.
+     */
+    private registerFormulaBuffer;
+    /**
+     * Removes an expression from the three internal maps: deletes it from
+     * the main `expressions` store, removes it from its parent's child-id
+     * and position indexes, and deletes its own child-id and position
+     * indexes.
+     *
+     * Callers remain responsible for collector notification, dirty-set
+     * cleanup, and parent dirtying — timing for those varies by call site.
+     */
+    private detachExpression;
+    /**
+     * Marks an expression and all its ancestors as dirty for hierarchical
+     * checksum recomputation. Stops early when it reaches an expression
+     * already in the dirty set (since its ancestors are already marked).
+     */
+    markExpressionDirty(exprId: string): void;
+    /**
+     * Recomputes `descendantChecksum` and `combinedChecksum` for all dirty
+     * expressions, processing bottom-up (deepest first) so that children
+     * are up-to-date before their parents are computed.
+     */
+    flushExpressionChecksums(): void;
+    /**
+     * Removes deleted expression IDs from the dirty set so that flush
+     * doesn't attempt to process expressions that no longer exist.
+     */
+    pruneDeletedFromDirtySet(deletedIds: Set<string>): void;
+    /** Returns all expressions sorted by ID for deterministic output. */
+    toArray(): TExpr[];
+    /**
+     * Adds an expression to the tree.
+     *
+     * @throws If the expression ID already exists.
+     * @throws If the expression references itself as parent.
+     * @throws If `implies`/`iff` operators have a non-null parentId (they must be roots).
+     * @throws If the parent does not exist or is not an operator/formula.
+     * @throws If the parent's child limit would be exceeded.
+     * @throws If the position is already occupied under the parent.
+     */
+    addExpression(input: TExpressionInput<TExpr>): void;
+    /**
+     * Adds an expression as the last child of the given parent.
+     *
+     * If the parent has no children, the expression gets `POSITION_INITIAL`.
+     * Otherwise it gets a midpoint between the last child's position and
+     * `POSITION_MAX`.
+     */
+    appendExpression(parentId: string | null, expression: TExpressionWithoutPosition<TExpr>): void;
+    /**
+     * Adds an expression immediately before or after an existing sibling.
+     *
+     * @throws If the sibling does not exist.
+     */
+    addExpressionRelative(siblingId: string, relativePosition: "before" | "after", expression: TExpressionWithoutPosition<TExpr>): void;
+    /**
+     * Updates mutable fields of an existing expression in-place.
+     *
+     * Only `position`, `variableId`, and `operator` may be updated. Structural
+     * fields (`id`, `parentId`, `type`, `argumentId`, `argumentVersion`,
+     * `checksum`) are forbidden.
+     *
+     * Operator changes are restricted to permitted swaps: `and`/`or` and
+     * `implies`/`iff`. Variable ID changes require the expression to be of
+     * type `"variable"`.
+     *
+     * @throws If the expression does not exist.
+     * @throws If a forbidden field is present in `updates`.
+     * @throws If an operator change is not permitted.
+     * @throws If `variableId` is set on a non-variable expression.
+     * @throws If the new position collides with a sibling.
+     */
+    updateExpression(expressionId: string, updates: TExpressionUpdate): TExpr;
+    /**
+     * Removes an expression from the tree.
+     *
+     * When `deleteSubtree` is `true`, the expression and its entire descendant
+     * subtree are removed, then {@link collapseIfNeeded} runs on the parent.
+     *
+     * When `deleteSubtree` is `false`, the expression is removed but its single
+     * child (if any) is promoted into the removed expression's slot.  If the
+     * expression has more than one child, an error is thrown.  Leaf removal
+     * (0 children) still triggers {@link collapseIfNeeded} on the parent.
+     * Promotion does **not** trigger collapse.
+     *
+     * @throws If `deleteSubtree` is `false` and the expression has multiple children.
+     * @throws If `deleteSubtree` is `false` and the single child is a root-only
+     *   operator (`implies`/`iff`) that would be placed in a non-root position.
+     * @returns The removed expression, or `undefined` if not found.
+     */
+    removeExpression(expressionId: string, deleteSubtree: boolean): TExpr | undefined;
+    private removeSubtree;
+    private removeAndPromote;
+    /**
+     * Promotes `child` into the slot occupied by `parent` and removes `parent`.
+     * Used by `collapseIfNeeded` and `normalize()`.
+     */
+    private promoteChild;
+    private collapseIfNeeded;
+    /**
+     * Checks whether the subtree rooted at `expressionId` contains a binary
+     * operator (`and` or `or`). Traversal stops at formula boundaries — a
+     * nested formula owns its own subtree and is not inspected.
+     */
+    private hasBinaryOperatorInBoundedSubtree;
+    /**
+     * Performs a full normalization sweep on the expression tree:
+     * 1. Collapses operators with 0 or 1 children.
+     * 2. Collapses formulas whose bounded subtree has no binary operator.
+     * 3. Inserts formula buffers where `enforceFormulaBetweenOperators` requires them.
+     * 4. Repeats until stable.
+     *
+     * Works regardless of the current `autoNormalize` setting — this is an
+     * explicit on-demand normalization.
+     */
+    normalize(): void;
+    /** Returns `true` if any expression in the tree references the given variable ID. */
+    hasVariableReference(variableId: string): boolean;
+    /** Returns the expression with the given ID, or `undefined` if not found. */
+    getExpression(expressionId: string): TExpr | undefined;
+    /** Returns the children of the given parent, sorted by position. */
+    getChildExpressions(parentId: string | null): TExpr[];
+    private loadInitialExpressions;
+    /**
+     * Simulates the collapse chain that would result from removing an expression.
+     * Throws if any promotion would violate nesting or root-only rules.
+     */
+    private assertRemovalSafe;
+    /**
+     * Checks whether promoting `child` into a slot with the given `newParentId`
+     * would violate the nesting rule or root-only rule.
+     */
+    private assertPromotionSafe;
+    /**
+     * Walks the collapse chain starting from `operatorId` after `removedChildId`
+     * is removed. At each level: if 0 remaining children, operator/formula is deleted
+     * and chain continues up. If 1 remaining child, check promotion safety.
+     */
+    private simulateCollapseChain;
+    /**
+     * After an operator promotion places `promotedChild` into `parentId`'s child set,
+     * check whether the parent (if a formula) would itself collapse. Formula collapse
+     * promotion is always safe (the child can't be a binary operator or root-only operator),
+     * but we need to continue the simulation chain.
+     */
+    private simulatePostPromotionCollapse;
+    private assertChildLimit;
+    private reparent;
+    /**
+     * Inserts a new expression between existing nodes in the tree.
+     *
+     * The new expression inherits the tree slot of the anchor node
+     * (`leftNodeId ?? rightNodeId`). The anchor and optional second node
+     * become children of the new expression at positions 0 and 1.
+     *
+     * Right node is reparented before left node to handle the case where
+     * the right node is a descendant of the left node's subtree.
+     *
+     * @throws If neither leftNodeId nor rightNodeId is provided.
+     * @throws If the expression ID already exists.
+     * @throws If leftNodeId and rightNodeId are the same.
+     * @throws If either referenced node does not exist.
+     * @throws If a unary operator/formula is given two children.
+     * @throws If either child is an `implies`/`iff` operator (cannot be subordinated).
+     * @throws If an `implies`/`iff` expression would be inserted at a non-root position.
+     */
+    insertExpression(expression: TExpressionInput<TExpr>, leftNodeId?: string, rightNodeId?: string): void;
+    /**
+     * Wraps an existing expression with a new operator and a new sibling.
+     *
+     * The operator takes the existing node's slot in the tree. Both the
+     * existing node and the new sibling become children of the operator.
+     *
+     * Exactly one of `leftNodeId` / `rightNodeId` must be provided — it
+     * identifies the existing node and which child slot (position 0 or 1)
+     * it occupies. The new sibling fills the other slot.
+     *
+     * @throws If neither or both of leftNodeId/rightNodeId are provided.
+     * @throws If the operator or sibling expression ID already exists.
+     * @throws If operator and sibling IDs are the same.
+     * @throws If the existing node does not exist.
+     * @throws If the operator is not of type `"operator"`.
+     * @throws If the operator is unary (`not`).
+     * @throws If the operator is `implies`/`iff` and the existing node is not at root.
+     * @throws If the existing node is an `implies`/`iff` operator (cannot be subordinated).
+     * @throws If the new sibling is an `implies`/`iff` operator (cannot be subordinated).
+     */
+    wrapExpression(operator: TExpressionWithoutPosition<TExpr>, newSibling: TExpressionWithoutPosition<TExpr>, leftNodeId?: string, rightNodeId?: string): void;
+    /**
+     * Reparents an expression to a new parent at a given position.
+     */
+    reparentExpression(expressionId: string, newParentId: string | null, newPosition: number): void;
+    /**
+     * Deletes a single expression that has no children.
+     * Does NOT trigger operator collapse. Caller must ensure children
+     * have been reparented away first.
+     */
+    deleteExpression(expressionId: string): TExpr | undefined;
+    /**
+     * Changes the operator type of an operator expression without the swap
+     * restriction enforced by {@link updateExpression}. Only validates that
+     * the target expression is an operator, the new operator is not `"not"`,
+     * and root-only constraints are satisfied.
+     */
+    changeOperatorType(expressionId: string, newOperator: TCoreLogicalOperatorType): TExpr;
+    /**
+     * Loads expressions in BFS order, respecting the current grammar config.
+     * Used by restoration paths (fromData, rollback) that load existing data.
+     */
+    loadExpressions(expressions: TExpressionInput<TExpr>[]): void;
+    /**
+     * Performs a comprehensive validation sweep on all managed expressions.
+     *
+     * Collects ALL violations rather than failing on the first one. Checks:
+     * schema validity, duplicate IDs, self-referential parents, parent
+     * existence, parent container type, root-only operators, formula-between-
+     * operators (when enabled), child limits, position uniqueness, and
+     * checksum integrity.
+     */
+    validate(): TInvariantValidationResult;
+    /** Returns a serializable snapshot of the current state. */
+    snapshot(): TExpressionManagerSnapshot<TExpr>;
+    /** Creates a new ExpressionManager from a previously captured snapshot. */
+    static fromSnapshot<TExpr extends TCorePropositionalExpression = TCorePropositionalExpression>(snapshot: TExpressionManagerSnapshot<TExpr>, grammarConfig?: TGrammarConfig, generateId?: () => string): ExpressionManager<TExpr>;
+}
+//# sourceMappingURL=expression-manager.d.ts.map

package/dist/lib/core/expression-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-manager.d.ts","sourceRoot":"","sources":["../../../src/lib/core/expression-manager.ts"],"names":[],"mappings":"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"}