@ldclabs/kip-lang 2.0.2 → 2.2.0

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAEvC,OAAO,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAE/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAEjD,OAAO,EACL,SAAS,EACT,QAAQ,EACR,SAAS,EACT,UAAU,EACV,SAAS,EACT,UAAU,EACV,WAAW,EACX,SAAS,EACT,QAAQ,EACR,gBAAgB,EACjB,MAAM,YAAY,CAAA;AAuHnB,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAC5D,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,EACrB,sBAAsB,EACvB,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AA8E9E,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAEvC,OAAO,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAE/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAEjD,OAAO,EACL,SAAS,EACT,QAAQ,EACR,SAAS,EACT,UAAU,EACV,SAAS,EACT,UAAU,EACV,WAAW,EACX,SAAS,EACT,QAAQ,EACR,gBAAgB,EACjB,MAAM,YAAY,CAAA;AAkHnB,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAC5D,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,EACrB,sBAAsB,EACvB,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AA6E9E,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA"}

package/dist/lower.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lower.d.ts","sourceRoot":"","sources":["../src/lower.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EAoDV,MAAM,UAAU,CAAA;AAEjB,OAAO,KAAK,EAKV,OAAO,EA4CR,MAAM,eAAe,CAAA;AA6FtB;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAa/C;AAED,6DAA6D;AAC7D,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,EAAE,CAKpD;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAsCvD"}
+{"version":3,"file":"lower.d.ts","sourceRoot":"","sources":["../src/lower.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EAgDV,MAAM,UAAU,CAAA;AAEjB,OAAO,KAAK,EAKV,OAAO,EA+CR,MAAM,eAAe,CAAA;AA6FtB;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAa/C;AAED,6DAA6D;AAC7D,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,EAAE,CAKpD;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAkCvD"}

package/dist/lower.js

@@ -122,14 +122,10 @@ export function lowerStatement(stmt) {
         case 'CreateAssertionStatement':
         case 'CreateActivityStatement':
         case 'UpdateStatement':
-        case 'RetractAssertionStatement':
-        case 'SupersedeAssertionStatement':
-        case 'CorrectEvidenceStatement':
-        case 'TransitionActivityStatement':
+        case 'TransitionStatement':
         case 'SetRetentionStatement':
-        case 'ArchiveStatement':
-        case 'TombstoneStatement':
         case 'PurgeStatement':
+        case 'PurgePayloadStatement':
         case 'MergeConceptStatement':
             const clauses = lowerMutationClause(stmt, 0);
             assertUniqueHandles(clauses, stmt.range);
@@ -165,15 +161,46 @@ function lowerFind(stmt) {
     };
 }
 function lowerAsOf(clause) {
-    const value = lowerScalar(clause.value);
-    switch (clause.basis) {
-        case 'SEQ':
-            return { Seq: value };
-        case 'TX':
-            return { Tx: value };
-        case 'TIME':
-            return { Time: value };
-    }
+    return { Seq: lowerScalar(clause.value) };
+}
+/**
+ * `{ expect_version_clause }` → at most one guard per plane. Two guards on one
+ * plane cannot both be meant, so the duplicate is rejected here rather than
+ * left for the engine to pick one.
+ */
+function lowerExpectVersions(clauses) {
+    const seen = new Set();
+    return clauses.map((clause) => {
+        let plane = null;
+        let key = 'element';
+        if (clause.plane) {
+            switch (clause.plane.kind) {
+                case 'ATTRIBUTES':
+                    plane = 'Attributes';
+                    key = 'attributes';
+                    break;
+                case 'STRUCTURAL':
+                    plane = 'Structural';
+                    key = 'structural';
+                    break;
+                case 'RETENTION':
+                    plane = 'Retention';
+                    key = 'retention';
+                    break;
+                case 'FACET': {
+                    const facet = lowerSymbol(clause.plane.facet);
+                    plane = { Facet: facet };
+                    key = 'facet:' + ('Name' in facet ? facet.Name : ':' + facet.Param);
+                    break;
+                }
+            }
+        }
+        if (seen.has(key)) {
+            throw invalidSyntax(`duplicate EXPECT VERSION guard on the same ${key === 'element' ? 'element' : 'plane'}`, clause.range);
+        }
+        seen.add(key);
+        return { version: lowerScalar(clause.value), plane };
+    });
 }
 function lowerFindExpression(expr) {
     if (expr.kind === 'AggregateExpr') {
@@ -641,45 +668,8 @@ function lowerMutationClause(stmt, seq) {
             return [{ CreateActivity: lowerRecordCreate(stmt) }];
         case 'UpdateStatement':
             return [{ Update: lowerUpdate(stmt) }];
-        case 'RetractAssertionStatement':
-            return [
-                {
-                    RetractAssertion: {
-                        target: lowerElementRef(stmt.target),
-                        where_clauses: stmt.where ? lowerWhere(stmt.where) : null,
-                        limit: stmt.limit ? lowerScalar(stmt.limit.value) : null,
-                        expect_state: stmt.expectState
-                            ? lowerScalar(stmt.expectState.value)
-                            : null
-                    }
-                }
-            ];
-        case 'SupersedeAssertionStatement':
-            return [
-                {
-                    SupersedeAssertion: {
-                        target: lowerElementRef(stmt.target),
-                        by: lowerElementRef(stmt.by),
-                        expect_state: stmt.expectState
-                            ? lowerScalar(stmt.expectState.value)
-                            : null
-                    }
-                }
-            ];
-        case 'CorrectEvidenceStatement':
-            return [
-                {
-                    CorrectEvidence: {
-                        target: lowerElementRef(stmt.target),
-                        by: lowerElementRef(stmt.by),
-                        expect_state: stmt.expectState
-                            ? lowerScalar(stmt.expectState.value)
-                            : null
-                    }
-                }
-            ];
-        case 'TransitionActivityStatement':
-            return [{ TransitionActivity: lowerTransition(stmt) }];
+        case 'TransitionStatement':
+            return [{ Transition: lowerTransition(stmt) }];
         case 'SetRetentionStatement':
             return [
                 {
@@ -688,18 +678,14 @@ function lowerMutationClause(stmt, seq) {
                         values: lowerAssignments(stmt.assignments, null),
                         where_clauses: stmt.where ? lowerWhere(stmt.where) : null,
                         limit: stmt.limit ? lowerScalar(stmt.limit.value) : null,
-                        expect_version: stmt.expectVersion
-                            ? lowerScalar(stmt.expectVersion.value)
-                            : null
+                        expect_versions: lowerExpectVersions(stmt.expectVersions)
                     }
                 }
             ];
-        case 'ArchiveStatement':
-            return [{ Archive: lowerRemoval(stmt) }];
-        case 'TombstoneStatement':
-            return [{ Tombstone: lowerRemoval(stmt) }];
         case 'PurgeStatement':
             return [{ Purge: lowerPurge(stmt) }];
+        case 'PurgePayloadStatement':
+            return [{ PurgePayload: lowerPurgePayload(stmt) }];
         case 'MergeConceptStatement':
             return [
                 {
@@ -707,9 +693,7 @@ function lowerMutationClause(stmt, seq) {
                         source: lowerElementRef(stmt.source),
                         into: lowerElementRef(stmt.into),
                         where_clauses: stmt.where ? lowerWhere(stmt.where) : null,
-                        expect_version: stmt.expectVersion
-                            ? lowerScalar(stmt.expectVersion.value)
-                            : null
+                        expect_versions: lowerExpectVersions(stmt.expectVersions)
                     }
                 }
             ];
@@ -771,9 +755,7 @@ function lowerUpsertConcept(stmt) {
     return {
         handle: varName(stmt.handle.name, stmt.handle.range),
         match,
-        expect_version: stmt.expectVersion
-            ? lowerScalar(stmt.expectVersion.value)
-            : null,
+        expect_versions: lowerExpectVersions(stmt.expectVersions),
         set_fields: stmt.setFields
             ? lowerAssignments(stmt.setFields.assignments, null)
             : null,
@@ -801,9 +783,7 @@ function lowerEnsureProposition(stmt) {
     return {
         handle: stmt.handle ? varName(stmt.handle.name, stmt.handle.range) : null,
         ...triple,
-        expect_version: stmt.expectVersion
-            ? lowerScalar(stmt.expectVersion.value)
-            : null
+        expect_versions: lowerExpectVersions(stmt.expectVersions)
     };
 }
 function lowerRecordCreate(stmt) {
@@ -822,7 +802,7 @@ function lowerRecordCreate(stmt) {
 }
 /**
  * Desugars `ASSERT` into exactly what the Spec defines it as (§55.1):
- * `ENSURE PROPOSITION` + `CREATE ASSERTION`, plus `SUPERSEDE` when written.
+ * `ENSURE PROPOSITION` + `CREATE ASSERTION`, plus `TRANSITION ... TO "superseded"` when `SUPERSEDING` is written.
  *
  * Nothing else is fabricated. The sugar exists because recording an
  * attributed claim is the hot path, not because it means anything new.
@@ -876,7 +856,7 @@ function lowerAssertSugar(stmt, seq) {
             EnsureProposition: {
                 handle: propositionHandle,
                 ...triple,
-                expect_version: null
+                expect_versions: []
             }
         }
     ];
@@ -929,16 +909,40 @@ function lowerAssertSugar(stmt, seq) {
     });
     if (stmt.superseding) {
         clauses.push({
-            SupersedeAssertion: {
+            Transition: {
                 target: lowerElementRef(stmt.superseding),
+                to: { Literal: { String: 'superseded' } },
                 by: { Handle: assertionHandle },
-                expect_state: null
+                set_fields: null,
+                set_structural: null,
+                where_clauses: null,
+                limit: null,
+                expect_versions: []
             }
         });
     }
     return clauses;
 }
+/** Moves that name the replacing element with `BY` (Spec §52.5). */
+const TRANSITION_WITH_BY = new Set(['superseded', 'corrected']);
+/** Activity status moves: the only ones that may finalize fields or topology. */
+const TRANSITION_ACTIVITY_STATES = new Set(['running', 'completed', 'failed', 'cancelled']);
 function lowerTransition(stmt) {
+    // Spec §52.5: BY exactly for superseded / corrected, SET clauses only on
+    // Activity states. These are syntax errors, so they belong to the
+    // executability contract, not only to the editor diagnostics.
+    if (stmt.to.kind === 'StringLiteral') {
+        const to = stmt.to.parsed;
+        if (TRANSITION_WITH_BY.has(to) && !stmt.by) {
+            throw invalidSyntax(`TRANSITION TO "${to}" names the replacing element with BY`, stmt.to.range);
+        }
+        if (!TRANSITION_WITH_BY.has(to) && stmt.by) {
+            throw invalidSyntax(`TRANSITION TO "${to}" takes no BY`, stmt.by.range);
+        }
+        if (stmt.finalize.length > 0 && !TRANSITION_ACTIVITY_STATES.has(to)) {
+            throw invalidSyntax(`TRANSITION TO "${to}" cannot finalize fields or topology; only a pending Activity does`, stmt.finalize[0].range);
+        }
+    }
     let setFields = null;
     let setStructural = null;
     for (const clause of stmt.finalize) {
@@ -958,17 +962,12 @@ function lowerTransition(stmt) {
     return {
         target: lowerElementRef(stmt.target),
         to: lowerScalar(stmt.to),
+        by: stmt.by ? lowerElementRef(stmt.by) : null,
         set_fields: setFields,
         set_structural: setStructural,
-        expect_state: stmt.expectState ? lowerScalar(stmt.expectState.value) : null
-    };
-}
-function lowerRemoval(stmt) {
-    return {
-        target: lowerElementRef(stmt.target),
         where_clauses: stmt.where ? lowerWhere(stmt.where) : null,
         limit: stmt.limit ? lowerScalar(stmt.limit.value) : null,
-        expect_state: stmt.expectState ? lowerScalar(stmt.expectState.value) : null
+        expect_versions: lowerExpectVersions(stmt.expectVersions)
     };
 }
 function lowerPurge(stmt) {
@@ -979,12 +978,25 @@ function lowerPurge(stmt) {
         target: lowerElementRef(stmt.target),
         where_clauses: stmt.where ? lowerWhere(stmt.where) : null,
         limit: stmt.limit ? lowerScalar(stmt.limit.value) : null,
+        expect_versions: lowerExpectVersions(stmt.expectVersions),
         reference_policy: stmt.referencePolicy
             ? lowerScalar(stmt.referencePolicy)
             : null,
         confirm: 'PURGE'
     };
 }
+function lowerPurgePayload(stmt) {
+    if (stmt.confirm.parsed !== 'PURGE') {
+        throw invalidSyntax('PURGE PAYLOAD must be confirmed with the exact literal "PURGE"', stmt.confirm.range);
+    }
+    return {
+        target: lowerElementRef(stmt.target),
+        where_clauses: stmt.where ? lowerWhere(stmt.where) : null,
+        limit: stmt.limit ? lowerScalar(stmt.limit.value) : null,
+        expect_versions: lowerExpectVersions(stmt.expectVersions),
+        confirm: 'PURGE'
+    };
+}
 // ---------------------------------------------------------------------------
 // UPDATE
 // ---------------------------------------------------------------------------
@@ -998,12 +1010,10 @@ function lowerUpdate(stmt) {
     const actions = stmt.actions.map((action) => lowerUpdateAction(action, targetVar, kind));
     return {
         target,
-        expect_version: stmt.expectVersion
-            ? lowerScalar(stmt.expectVersion.value)
-            : null,
         actions,
         where_clauses: stmt.where ? lowerWhere(stmt.where) : null,
-        limit: stmt.limit ? lowerScalar(stmt.limit.value) : null
+        limit: stmt.limit ? lowerScalar(stmt.limit.value) : null,
+        expect_versions: lowerExpectVersions(stmt.expectVersions)
     };
 }
 function boundKindOf(variable, patterns) {
@@ -1086,18 +1096,18 @@ function lowerUpdateAction(action, targetVar, kind) {
  * Structural mutation reaches mutable Concept topology only (Spec §17.5).
  * Record kinds keep their topology: an Assertion's citations and an
  * Evidence's lineage are immutable payload, a Proposition has no structural
- * fields, and a pending Activity finalizes through TRANSITION ACTIVITY.
+ * fields, and a pending Activity finalizes through TRANSITION.
  */
 function guardStructuralMutation(verb, kind, range) {
     switch (kind) {
         case 'assertion':
             throw invalidSyntax(`${verb} cannot change an Assertion's citations: they are immutable payload — record a new Assertion with SUPERSEDING`, range);
         case 'evidence':
-            throw invalidSyntax(`${verb} cannot change Evidence topology: correct it with CORRECT EVIDENCE :old BY :new`, range);
+            throw invalidSyntax(`${verb} cannot change Evidence topology: correct it with TRANSITION :old TO "corrected" BY :new`, range);
         case 'proposition':
             throw invalidSyntax(`${verb} has no target on a Proposition: a Proposition is its tuple and carries no structural fields`, range);
         case 'activity':
-            throw invalidSyntax(`${verb} cannot change Activity topology: finalize a pending Activity with TRANSITION ACTIVITY ... SET STRUCTURAL; a terminal Activity is immutable`, range);
+            throw invalidSyntax(`${verb} cannot change Activity topology: finalize a pending Activity with TRANSITION ... TO "completed" SET STRUCTURAL; a terminal Activity is immutable`, range);
         default:
             return;
     }
@@ -1115,7 +1125,7 @@ function guardImmutableField(field, kind, range) {
             'never by rewriting the old one', range);
     }
     if (kind === 'evidence' && EVIDENCE_IMMUTABLE.has(field)) {
-        throw invalidSyntax(`${field} is immutable Evidence payload: correct it with CORRECT EVIDENCE :old BY :new`, range);
+        throw invalidSyntax(`${field} is immutable Evidence payload: correct it with TRANSITION :old TO "corrected" BY :new`, range);
     }
     if (kind === 'proposition' && PROPOSITION_IMMUTABLE.has(field)) {
         throw invalidSyntax(`${field} is part of the immutable Proposition tuple: a different tuple is a different Proposition`, range);
@@ -1331,8 +1341,6 @@ function lowerMeta(stmt) {
                         }
                     }
             };
-        case 'SnapshotStatement':
-            return { Snapshot: { as_of: stmt.asOf ? lowerAsOf(stmt.asOf) : null } };
         case 'ExportCapsuleStatement':
             return { ExportCapsule: lowerExport(stmt) };
         default:
@@ -1360,7 +1368,8 @@ const LIST_TARGETS = {
     PREDICATES: 'Predicates',
     FACETS: 'Facets',
     STRUCTURAL_FIELDS: 'StructuralFields',
-    EPISTEMIC_POLICIES: 'EpistemicPolicies'
+    EPISTEMIC_POLICIES: 'EpistemicPolicies',
+    DEPENDENTS: 'Dependents'
 };
 const SEARCH_TARGETS = {
     CONCEPT: 'Concept',
@@ -1382,8 +1391,6 @@ function lowerDescribe(stmt) {
             return { Primer: { mode: stmt.mode ? lowerScalar(stmt.mode) : null } };
         case 'PROTOCOL':
             return 'Protocol';
-        case 'EXECUTION_CONTEXT':
-            return 'ExecutionContext';
         case 'CAPABILITIES':
             return 'Capabilities';
         case 'SPACE':
@@ -1416,15 +1423,18 @@ function lowerDescribe(stmt) {
         case 'TRANSACTION_BY_IDEMPOTENCY_KEY':
             return { TransactionByIdempotencyKey: value() };
         case 'SNAPSHOT':
-            return { Snapshot: { as_of: stmt.asOf ? lowerAsOf(stmt.asOf) : null } };
+            return {
+                Snapshot: {
+                    as_of: stmt.asOf ? lowerAsOf(stmt.asOf) : null,
+                    at_time: stmt.atTime ? lowerScalar(stmt.atTime) : null
+                }
+            };
         case 'CAPSULE':
             return { Capsule: value() };
         case 'EPISTEMIC_POLICY':
             return {
                 EpistemicPolicy: { value: stmt.value ? lowerScalar(stmt.value) : null }
             };
-        case 'PROJECTION_CAPABILITY':
-            return 'ProjectionCapability';
         case 'TRUST':
             return { Trust: { value: stmt.value ? lowerScalar(stmt.value) : null } };
         case 'ACCESS':
@@ -1434,9 +1444,14 @@ function lowerDescribe(stmt) {
     }
 }
 function lowerList(stmt) {
+    if (stmt.target === 'DEPENDENTS' && !stmt.element) {
+        throw invalidSyntax('LIST DEPENDENTS requires an element operand', stmt.range);
+    }
     return {
         target: LIST_TARGETS[stmt.target],
         status: stmt.status ? lowerScalar(stmt.status) : null,
+        element: stmt.element ? lowerScalar(stmt.element) : null,
+        depth: stmt.depth ? lowerScalar(stmt.depth) : null,
         limit: stmt.limit ? lowerScalar(stmt.limit.value) : null,
         cursor: stmt.cursor ? lowerScalar(stmt.cursor.value) : null
     };