@ldclabs/kip-lang 2.0.2 → 2.2.0

package/src/semantics.ts

@@ -48,13 +48,27 @@ const MODES = new Set([
   'imported'
 ])
 const SEARCH_MODES = new Set(['keyword', 'semantic', 'hybrid'])
-const ASSERTION_STATES = new Set([
-  'active',
+/**
+ * Everything `TRANSITION ... TO` may name (Spec §52.5): Assertion revision,
+ * Evidence correction, Activity status, and the storage lifecycle any element
+ * has. The engine matches the state to the target's kind; the toolkit can only
+ * reject a word that belongs to none of them.
+ */
+const TRANSITION_STATES = new Set([
   'retracted',
   'superseded',
-  'expired'
+  'corrected',
+  'running',
+  'completed',
+  'failed',
+  'cancelled',
+  'archived',
+  'tombstoned'
 ])
-const ACTIVITY_TERMINAL = new Set(['completed', 'failed', 'cancelled'])
+/** Moves that name the replacing element with `BY`. */
+const TRANSITION_WITH_BY = new Set(['superseded', 'corrected'])
+/** Moves that may finalize an Activity's fields and topology. */
+const ACTIVITY_STATES = new Set(['running', 'completed', 'failed', 'cancelled'])
 const EVIDENCE_ROLES = new Set(['support', 'challenge', 'context'])
 
 /** Signals the Profile fixes to `[0,1]`; none of them is truth. */
@@ -127,42 +141,51 @@ function analyzeMutationClause(stmt: Statement, diags: Diagnostic[]): void {
       if (stmt.where) checkWhere(stmt.where, !!stmt.limit, diags)
       break
 
-    // `EXPECT STATE` is checkable only where the target's kind is fixed by the
-    // statement itself. RETRACT and SUPERSEDE always name an Assertion, so the
-    // Assertion lifecycle registry applies. ARCHIVE and TOMBSTONE take any
-    // element — a Concept is not `retracted` and may well be `archived` — and
-    // Core registers no element-lifecycle vocabulary, so checking them here
-    // rejected commands the Specification admits.
-    case 'RetractAssertionStatement':
-      if (stmt.expectState) {
-        checkEnum(stmt.expectState.value, ASSERTION_STATES, 'EXPECT STATE', diags)
-      }
-      if (stmt.where) checkWhere(stmt.where, !!stmt.limit, diags)
-      break
-
-    case 'SupersedeAssertionStatement':
-      if (stmt.expectState) {
-        checkEnum(stmt.expectState.value, ASSERTION_STATES, 'EXPECT STATE', diags)
+    // The target's kind is not known statically, so only the vocabulary is
+    // checkable: a state no kind has, a `BY` on a move that takes none, a
+    // finalize clause on a move that is not an Activity's.
+    case 'TransitionStatement': {
+      checkEnum(stmt.to, TRANSITION_STATES, 'TRANSITION TO', diags)
+      if (stmt.to.kind === 'StringLiteral') {
+        const to = stmt.to.parsed
+        if (TRANSITION_WITH_BY.has(to) && !stmt.by) {
+          diags.push({
+            range: stmt.to.range,
+            severity: 'error',
+            message: `TRANSITION TO "${to}" names the replacing element with BY`,
+            code: 'KIP_2001'
+          })
+        }
+        if (!TRANSITION_WITH_BY.has(to) && stmt.by && TRANSITION_STATES.has(to)) {
+          diags.push({
+            range: stmt.by.range,
+            severity: 'error',
+            message: `TRANSITION TO "${to}" takes no BY`,
+            code: 'KIP_2001'
+          })
+        }
+        if (stmt.finalize.length > 0 && !ACTIVITY_STATES.has(to) && TRANSITION_STATES.has(to)) {
+          diags.push({
+            range: stmt.finalize[0].range,
+            severity: 'error',
+            message: `TRANSITION TO "${to}" cannot finalize fields or topology; only a pending Activity does`,
+            code: 'KIP_2001'
+          })
+        }
       }
-      break
-
-    case 'ArchiveStatement':
-    case 'TombstoneStatement':
-      if (stmt.where) checkWhere(stmt.where, !!stmt.limit, diags)
-      break
-
-    case 'TransitionActivityStatement':
-      checkEnum(stmt.to, ACTIVITY_TERMINAL, 'TRANSITION ACTIVITY TO', diags)
       checkStructural(stmt.finalize.find(
         (c): c is SetStructuralClause => c.kind === 'SetStructuralClause'
       ), diags)
+      if (stmt.where) checkWhere(stmt.where, !!stmt.limit, diags)
       break
+    }
 
-    // Spec §52.7 names six statements whose WHERE can select an unbounded set
-    // and which SHOULD therefore carry a LIMIT. Warning on the read and on
+    // Spec §52.7 names seven statements whose WHERE can select an unbounded
+    // set and which SHOULD therefore carry a LIMIT. Warning on the read and on
     // UPDATE while staying silent on the removal ladder had it backwards: an
     // over-broad PURGE is the one that cannot be undone.
     case 'PurgeStatement':
+    case 'PurgePayloadStatement':
     case 'SetRetentionStatement':
       if (stmt.where) checkWhere(stmt.where, !!stmt.limit, diags)
       break
@@ -376,12 +399,15 @@ function collectHandleRefs(
       }
       break
 
-    case 'SupersedeAssertionStatement':
-    case 'CorrectEvidenceStatement':
-      for (const ref of [clause.target, clause.by]) {
-        if (ref.kind === 'VariableRef') {
-          out.push({ name: ref.name.slice(1), range: ref.range })
-        }
+    case 'TransitionStatement':
+      // `BY ?new` resolves inside the plan; a `?target` is bound by WHERE or
+      // by a handle, so only the replacing element is a plan reference.
+      if (clause.by && clause.by.kind === 'VariableRef') {
+        out.push({ name: clause.by.name.slice(1), range: clause.by.range })
+      }
+      for (const fin of clause.finalize) {
+        if (fin.kind === 'SetFieldsClause') fromObject(fin.assignments)
+        else for (const edge of fin.assignments) fromExpression(edge.value)
       }
       break
   }

package/src/token.ts

@@ -33,8 +33,8 @@ export enum TokenType {
   Distinct = 'DISTINCT',
   As = 'AS',
   Of = 'OF',
+  At = 'AT',
   Seq = 'SEQ',
-  Tx = 'TX',
   Time = 'TIME',
   For = 'FOR',
   Epistemic = 'EPISTEMIC',
@@ -55,16 +55,12 @@ export enum TokenType {
   Assert = 'ASSERT',
   Superseding = 'SUPERSEDING',
   Update = 'UPDATE',
-  Retract = 'RETRACT',
-  Supersede = 'SUPERSEDE',
-  Correct = 'CORRECT',
   Transition = 'TRANSITION',
   Set = 'SET',
   Unset = 'UNSET',
   Retention = 'RETENTION',
-  Archive = 'ARCHIVE',
-  Tombstone = 'TOMBSTONE',
   Purge = 'PURGE',
+  Payload = 'PAYLOAD',
   Confirm = 'CONFIRM',
   Reference = 'REFERENCE',
   Policy = 'POLICY',
@@ -81,7 +77,6 @@ export enum TokenType {
   Facet = 'FACET',
   Expect = 'EXPECT',
   Version = 'VERSION',
-  State = 'STATE',
 
   // ── Keywords — META ───────────────────────────────────────────────
   Describe = 'DESCRIBE',
@@ -97,10 +92,7 @@ export enum TokenType {
   Primer = 'PRIMER',
   Mode = 'MODE',
   Protocol = 'PROTOCOL',
-  Execution = 'EXECUTION',
-  Context = 'CONTEXT',
   Capabilities = 'CAPABILITIES',
-  Capability = 'CAPABILITY',
   Space = 'SPACE',
   Spaces = 'SPACES',
   Schema = 'SCHEMA',
@@ -113,13 +105,14 @@ export enum TokenType {
   Facets = 'FACETS',
   Types = 'TYPES',
   Policies = 'POLICIES',
+  Dependents = 'DEPENDENTS',
+  Depth = 'DEPTH',
   Compatibility = 'COMPATIBILITY',
   From = 'FROM',
   Error = 'ERROR',
   Transaction = 'TRANSACTION',
   Idempotency = 'IDEMPOTENCY',
   Capsule = 'CAPSULE',
-  Projection = 'PROJECTION',
   Trust = 'TRUST',
   Access = 'ACCESS',
   With = 'WITH',
@@ -213,8 +206,8 @@ export const KEYWORDS: ReadonlyMap<string, TokenType> = new Map([
   ['DISTINCT', TokenType.Distinct],
   ['AS', TokenType.As],
   ['OF', TokenType.Of],
+  ['AT', TokenType.At],
   ['SEQ', TokenType.Seq],
-  ['TX', TokenType.Tx],
   ['TIME', TokenType.Time],
   ['FOR', TokenType.For],
   ['EPISTEMIC', TokenType.Epistemic],
@@ -235,16 +228,12 @@ export const KEYWORDS: ReadonlyMap<string, TokenType> = new Map([
   ['ASSERT', TokenType.Assert],
   ['SUPERSEDING', TokenType.Superseding],
   ['UPDATE', TokenType.Update],
-  ['RETRACT', TokenType.Retract],
-  ['SUPERSEDE', TokenType.Supersede],
-  ['CORRECT', TokenType.Correct],
   ['TRANSITION', TokenType.Transition],
   ['SET', TokenType.Set],
   ['UNSET', TokenType.Unset],
   ['RETENTION', TokenType.Retention],
-  ['ARCHIVE', TokenType.Archive],
-  ['TOMBSTONE', TokenType.Tombstone],
   ['PURGE', TokenType.Purge],
+  ['PAYLOAD', TokenType.Payload],
   ['CONFIRM', TokenType.Confirm],
   ['REFERENCE', TokenType.Reference],
   ['POLICY', TokenType.Policy],
@@ -261,7 +250,6 @@ export const KEYWORDS: ReadonlyMap<string, TokenType> = new Map([
   ['FACET', TokenType.Facet],
   ['EXPECT', TokenType.Expect],
   ['VERSION', TokenType.Version],
-  ['STATE', TokenType.State],
 
   // META
   ['DESCRIBE', TokenType.Describe],
@@ -277,10 +265,7 @@ export const KEYWORDS: ReadonlyMap<string, TokenType> = new Map([
   ['PRIMER', TokenType.Primer],
   ['MODE', TokenType.Mode],
   ['PROTOCOL', TokenType.Protocol],
-  ['EXECUTION', TokenType.Execution],
-  ['CONTEXT', TokenType.Context],
   ['CAPABILITIES', TokenType.Capabilities],
-  ['CAPABILITY', TokenType.Capability],
   ['SPACE', TokenType.Space],
   ['SPACES', TokenType.Spaces],
   ['SCHEMA', TokenType.Schema],
@@ -293,13 +278,14 @@ export const KEYWORDS: ReadonlyMap<string, TokenType> = new Map([
   ['FACETS', TokenType.Facets],
   ['TYPES', TokenType.Types],
   ['POLICIES', TokenType.Policies],
+  ['DEPENDENTS', TokenType.Dependents],
+  ['DEPTH', TokenType.Depth],
   ['COMPATIBILITY', TokenType.Compatibility],
   ['FROM', TokenType.From],
   ['ERROR', TokenType.Error],
   ['TRANSACTION', TokenType.Transaction],
   ['IDEMPOTENCY', TokenType.Idempotency],
   ['CAPSULE', TokenType.Capsule],
-  ['PROJECTION', TokenType.Projection],
   ['TRUST', TokenType.Trust],
   ['ACCESS', TokenType.Access],
   ['WITH', TokenType.With],

package/src/version.ts

@@ -7,7 +7,7 @@
  * has to load in runtimes with no filesystem; `test/lower.test.mjs` asserts the
  * two stay in step.
  */
-export const PARSER_VERSION = '2.0.2'
+export const PARSER_VERSION = '2.2.0'
 
 /** The KIP specification revision this grammar targets. */
 export const KIP_SPEC_REVISION = '2.0-draft'