@ldclabs/kip-lang 2.2.0 → 2.3.1

package/src/canonical.ts

@@ -0,0 +1,117 @@
+/** Portable KIP JSON: RFC 8785 serialization with safe integral values. */
+export function portableNumber(value: number, raw?: string): number {
+  if (!Number.isFinite(value)) throw new Error('only finite numbers are valid KIP values')
+  if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+    throw new Error('number is outside the range of portable exact integers; use a schema-defined string value')
+  }
+  // Inspect the significand, not the exponent: 0e-400 is still exactly zero.
+  if (value === 0 && raw && /[1-9]/.test(raw.split(/[eE]/)[0])) {
+    throw new Error('nonzero number underflows to zero')
+  }
+  return Object.is(value, -0) ? 0 : value
+}
+
+function scalarString(value: string): string {
+  for (let i = 0; i < value.length; i++) {
+    const c = value.charCodeAt(i)
+    if (c >= 0xd800 && c <= 0xdbff) {
+      const next = value.charCodeAt(++i)
+      if (!(next >= 0xdc00 && next <= 0xdfff)) throw new Error('unpaired Unicode surrogate')
+    } else if (c >= 0xdc00 && c <= 0xdfff) throw new Error('unpaired Unicode surrogate')
+  }
+  return JSON.stringify(value)
+}
+
+/**
+ * Serialize JSON values using JCS (UTF-16 key order, ECMAScript numbers,
+ * no Unicode normalization). KIP narrows integral values to safe integers.
+ * Semantic NFC normalization belongs to Literal construction, not hashing.
+ */
+export function canonicalize(value: unknown): string {
+  const ancestors = new Set<object>()
+  function emit(item: unknown, depth: number): string {
+    if (depth > 128) throw new Error('JSON nesting limit exceeded')
+    if (item === null) return 'null'
+    if (typeof item === 'string') return scalarString(item)
+    if (typeof item === 'number') return JSON.stringify(portableNumber(item))
+    if (typeof item === 'boolean') return item ? 'true' : 'false'
+    if (typeof item !== 'object') throw new Error('not a JSON value')
+    if (ancestors.has(item)) throw new Error('cyclic JSON value')
+    ancestors.add(item)
+    let result: string
+    if (Array.isArray(item)) {
+      result = '[' + Array.from(item, v => emit(v, depth + 1)).join(',') + ']'
+    } else {
+      const proto = Object.getPrototypeOf(item)
+      if (proto !== Object.prototype && proto !== null) throw new Error('not a plain JSON object')
+      const object = item as Record<string, unknown>
+      result = '{' + Object.keys(object).sort().map(key =>
+        scalarString(key) + ':' + emit(object[key], depth + 1)
+      ).join(',') + '}'
+    }
+    ancestors.delete(item)
+    return result
+  }
+  return emit(value, 0)
+}
+
+/** Decode before hashing/binding, rejecting duplicate decoded keys and loss. */
+export function parseCanonicalJson(source: string): unknown {
+  let pos = 0
+  function whitespace() { while (/[\x20\t\n\r]/.test(source[pos] ?? '\0')) pos++ }
+  function string(): string {
+    const start = pos++
+    while (pos < source.length) {
+      const c = source[pos++]
+      if (c === '\\') { pos++; continue }
+      if (c === '"') {
+        const result: string = JSON.parse(source.slice(start, pos))
+        scalarString(result)
+        return result
+      }
+    }
+    throw new Error('unterminated JSON string')
+  }
+  function value(depth: number): unknown {
+    if (depth > 128) throw new Error('JSON nesting limit exceeded')
+    whitespace()
+    if (source[pos] === '"') return string()
+    if (source[pos] === '{') {
+      pos++; whitespace()
+      const result: Record<string, unknown> = Object.create(null)
+      if (source[pos] === '}') { pos++; return result }
+      while (true) {
+        whitespace()
+        if (source[pos] !== '"') throw new Error('expected JSON property name')
+        const key = string(); whitespace()
+        if (Object.hasOwn(result, key)) throw new Error('duplicate JSON property: ' + key)
+        if (source[pos++] !== ':') throw new Error('expected colon')
+        result[key] = value(depth + 1); whitespace()
+        const end = source[pos++]
+        if (end === '}') return result
+        if (end !== ',') throw new Error('expected comma or closing brace')
+      }
+    }
+    if (source[pos] === '[') {
+      pos++; whitespace()
+      const result: unknown[] = []
+      if (source[pos] === ']') { pos++; return result }
+      while (true) {
+        result.push(value(depth + 1)); whitespace()
+        const end = source[pos++]
+        if (end === ']') return result
+        if (end !== ',') throw new Error('expected comma or closing bracket')
+      }
+    }
+    for (const [token, result] of [['true', true], ['false', false], ['null', null]] as const) {
+      if (source.startsWith(token, pos)) { pos += token.length; return result }
+    }
+    const match = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/.exec(source.slice(pos))
+    if (!match) throw new Error('invalid JSON value')
+    pos += match[0].length
+    return portableNumber(Number(match[0]), match[0])
+  }
+  const result = value(0); whitespace()
+  if (pos !== source.length) throw new Error('trailing JSON content')
+  return result
+}

package/src/exec-ast.ts

@@ -574,8 +574,6 @@ export type VerifyTarget =
   | 'Capsule'
   | 'SchemaPackage'
   | 'Receipt'
-  | 'Blob'
-  | 'Checkpoint'
 
 export interface ValidateCommand {
   target: ValidateTarget

package/src/formatter.ts

@@ -1000,9 +1000,7 @@ class Formatter {
     const words: Record<VerifyStatement['target'], string> = {
       CAPSULE: 'CAPSULE',
       SCHEMA_PACKAGE: 'SCHEMA PACKAGE',
-      RECEIPT: 'RECEIPT',
-      BLOB: 'BLOB',
-      CHECKPOINT: 'CHECKPOINT'
+      RECEIPT: 'RECEIPT'
     }
     this.writeIndent()
     this.write(`VERIFY ${words[stmt.target]} ${this.scalar(stmt.value)}`)

package/src/index.ts

@@ -1,4 +1,5 @@
 export { tokenize } from './lexer.js'
+export { canonicalize, parseCanonicalJson } from './canonical.js'
 export { parse } from './parser.js'
 export type { ParseResult } from './parser.js'
 export { format } from './formatter.js'

package/src/lower.ts

@@ -50,6 +50,7 @@ import type {
   NumberLiteral
 } from './ast.js'
 import { invalidSyntax } from './errors.js'
+import { portableNumber } from './canonical.js'
 import type {
   AggregationFunction,
   Assignments,
@@ -161,7 +162,8 @@ const PROTECTED_FIELDS = new Set([
   '_system',
   'governance',
   'space_id',
-  'space_seq'
+  'space_seq',
+  'merged_into'
 ])
 
 /**
@@ -1657,7 +1659,7 @@ function lowerUpdateExpr(
 
     case 'UnaryExpression':
       if (expr.operator === '-' && expr.operand.kind === 'NumberLiteral') {
-        return { Number: -numberValue(expr.operand) }
+        return { Number: portableNumber(-numberValue(expr.operand)) }
       }
       throw invalidSyntax(
         `expected a number, a parameter, the target's own field or a registered function, found ${describeExpression(expr)}`,
@@ -1770,9 +1772,7 @@ function lowerMeta(stmt: Statement): MetaCommand {
 const VERIFY_TARGETS: Record<VerifyStatement['target'], VerifyTarget> = {
   CAPSULE: 'Capsule',
   SCHEMA_PACKAGE: 'SchemaPackage',
-  RECEIPT: 'Receipt',
-  BLOB: 'Blob',
-  CHECKPOINT: 'Checkpoint'
+  RECEIPT: 'Receipt'
 }
 
 const VALIDATE_TARGETS: Record<ValidateStatement['target'], ValidateTarget> = {
@@ -1989,56 +1989,13 @@ function lowerElementRef(ref: TargetRef): ElementRef {
 // Numeric literals
 // ---------------------------------------------------------------------------
 
-/** `i64::MIN` — the most negative integer a KIP number literal may spell. */
-const INT_MIN = -(2n ** 63n)
-/** `u64::MAX` — the largest. */
-const INT_MAX = 2n ** 64n - 1n
-
-/** An integer literal: no fraction, no exponent, so it is read as an integer. */
-const INTEGER_FORM = /^-?\d+$/
-
-/**
- * The value of a number literal, refusing the ones that cannot survive being
- * one.
- *
- * A JavaScript number is a double, so `18446744073709551617` silently becomes
- * `18446744073709551616` on the way in. Accepting that would be the worst
- * possible outcome: the command does not fail, it *executes with a different
- * number than it says*, and no engine downstream can detect it — by the time
- * an executable AST exists the digits are gone. So the check happens here,
- * against the raw text, which is the only place the original is still around.
- *
- * The bounds are the reference grammar's: an integer literal is read as an
- * `i64` or a `u64` and must fit one of them, and any other form must parse to a
- * finite double. `18446744073709551616.0` is therefore accepted where
- * `18446744073709551616` is not — the float form is claiming an approximation,
- * and the integer form is claiming an exact value it cannot deliver.
- *
- * Integers above 2^53 still lose precision in this implementation's `value`
- * even though they are accepted, because a double cannot hold them. That is a
- * property of the host, not a disagreement about the language: both engines
- * agree the command is legal, and a runtime that needs the exact digits has
- * `raw`.
- */
+/** Never discard exact integer digits or silently turn a nonzero value into zero. */
 function numberValue(node: NumberLiteral): number {
-  if (INTEGER_FORM.test(node.raw)) {
-    const exact = BigInt(node.raw)
-    if (exact < INT_MIN || exact > INT_MAX) {
-      throw invalidSyntax(
-        `${node.raw} is outside the range a KIP integer literal can represent ` +
-          `(${INT_MIN} to ${INT_MAX})`,
-        node.range
-      )
-    }
-    return node.value
-  }
-  if (!Number.isFinite(node.value)) {
-    throw invalidSyntax(
-      `only finite numbers are valid KIP literals, found ${node.raw}`,
-      node.range
-    )
+  try {
+    return portableNumber(node.value, node.raw)
+  } catch (error) {
+    throw invalidSyntax(`${(error as Error).message}: ${node.raw}`, node.range)
   }
-  return node.value
 }
 
 function lowerKipValue(expr: Expression): KipValue {
@@ -2057,11 +2014,10 @@ function lowerKipValue(expr: Expression): KipValue {
     case 'ObjectPattern': {
       const entries =
         expr.kind === 'ObjectLiteral' ? expr.entries : expr.members
-      const out: Record<string, KipValue> = {}
-      for (const entry of entries) {
-        out[entry.key] = lowerKipValue(entry.value)
-      }
-      return { Object: out }
+      // Create data properties even for names such as __proto__.
+      return { Object: Object.fromEntries(entries.map(entry =>
+        [entry.key, lowerKipValue(entry.value)]
+      )) }
     }
     case 'UnaryExpression':
       if (expr.operator === '-' && expr.operand.kind === 'NumberLiteral') {
@@ -2084,11 +2040,9 @@ function lowerKipValue(expr: Expression): KipValue {
  * lets a parameter stand anywhere inside them.
  */
 function lowerBoundObject(object: ObjectLiteral): Record<string, BoundValue> {
-  const out: Record<string, BoundValue> = {}
-  for (const entry of object.entries) {
-    out[entry.key] = lowerBoundValue(entry.value, null)
-  }
-  return out
+  return Object.fromEntries(object.entries.map(entry =>
+    [entry.key, lowerBoundValue(entry.value, null)]
+  ))
 }
 
 /** Strips the `?` sigil; the executable form carries bare names. */

package/src/parser.ts

@@ -2235,14 +2235,6 @@ class Parser {
         this.expectSecondWord(TokenType.Receipt, verify)
         target = 'RECEIPT'
         break
-      case TokenType.Blob:
-        this.expectSecondWord(TokenType.Blob, verify)
-        target = 'BLOB'
-        break
-      case TokenType.Checkpoint:
-        this.expectSecondWord(TokenType.Checkpoint, verify)
-        target = 'CHECKPOINT'
-        break
       default:
         this.error(`Unknown VERIFY target '${tok.value}'`, tok)
         throw new ParseAbort()

package/src/token.ts

@@ -120,8 +120,6 @@ export enum TokenType {
   Cognition = 'COGNITION',
   Threshold = 'THRESHOLD',
   Receipt = 'RECEIPT',
-  Blob = 'BLOB',
-  Checkpoint = 'CHECKPOINT',
   Kql = 'KQL',
   Kml = 'KML',
   Import = 'IMPORT',
@@ -293,8 +291,6 @@ export const KEYWORDS: ReadonlyMap<string, TokenType> = new Map([
   ['COGNITION', TokenType.Cognition],
   ['THRESHOLD', TokenType.Threshold],
   ['RECEIPT', TokenType.Receipt],
-  ['BLOB', TokenType.Blob],
-  ['CHECKPOINT', TokenType.Checkpoint],
   ['KQL', TokenType.Kql],
   ['KML', TokenType.Kml],
   ['IMPORT', TokenType.Import],

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.2.0'
+export const PARSER_VERSION = '2.3.1'
 
 /** The KIP specification revision this grammar targets. */
 export const KIP_SPEC_REVISION = '2.0-draft'