@yakcc/cli 0.5.0-alpha.0

package/dist/blocks/char-code/spec.yak

@@ -0,0 +1,80 @@
+{
+  "name": "char-code",
+  "inputs": [
+    {
+      "name": "input",
+      "type": "string",
+      "description": "The full input string."
+    },
+    {
+      "name": "position",
+      "type": "number",
+      "description": "Zero-based index to read from."
+    }
+  ],
+  "outputs": [
+    {
+      "name": "code",
+      "type": "number",
+      "description": "UTF-16 char code at position, in [0, 65535]."
+    }
+  ],
+  "preconditions": [],
+  "postconditions": [],
+  "invariants": [],
+  "effects": [],
+  "level": "L0",
+  "behavior": "Return the UTF-16 char code of the character at the given position in the input string. Throws RangeError if position is negative or out of bounds.",
+  "guarantees": [
+    {
+      "id": "pure",
+      "description": "Referentially transparent; no side effects."
+    },
+    {
+      "id": "non-negative",
+      "description": "Result is always >= 0."
+    },
+    {
+      "id": "bounded",
+      "description": "Result is in [0, 65535]."
+    }
+  ],
+  "errorConditions": [
+    {
+      "description": "position < 0.",
+      "errorType": "RangeError"
+    },
+    {
+      "description": "position >= input.length.",
+      "errorType": "RangeError"
+    }
+  ],
+  "nonFunctional": {
+    "time": "O(1)",
+    "space": "O(1)",
+    "purity": "pure",
+    "threadSafety": "safe"
+  },
+  "propertyTests": [
+    {
+      "id": "char-code-zero",
+      "description": "charCode('0abc', 0) returns 48"
+    },
+    {
+      "id": "char-code-a",
+      "description": "charCode('abc', 0) returns 97"
+    },
+    {
+      "id": "char-code-oob",
+      "description": "charCode('abc', 3) throws RangeError"
+    },
+    {
+      "id": "char-code-negative",
+      "description": "charCode('abc', -1) throws RangeError"
+    },
+    {
+      "id": "char-code-bracket",
+      "description": "charCode('[', 0) returns 91"
+    }
+  ]
+}

package/dist/blocks/comma/impl.ts

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+// @decision DEC-SEEDS-COMMA-001: comma follows the same positional combinator convention as bracket.
+// Status: implemented (WI-006)
+// Rationale: Consistent positional-return API across all terminal matchers means they
+// can be composed without wrapping. Returns next position rather than a boolean.
+
+export function comma(input: string, position: number): number {
+  if (position < 0) {
+    throw new RangeError(`Position ${position} is negative`);
+  }
+  if (position >= input.length) {
+    throw new SyntaxError(`Expected ',' at position ${position} but reached end of input`);
+  }
+  if (input[position] !== ",") {
+    throw new SyntaxError(
+      `Expected ',' at position ${position} but found ${JSON.stringify(input[position])}`,
+    );
+  }
+  return position + 1;
+}

package/dist/blocks/comma/proof/manifest.json

@@ -0,0 +1,8 @@
+{
+  "artifacts": [
+    {
+      "kind": "property_tests",
+      "path": "tests.fast-check.ts"
+    }
+  ]
+}

package/dist/blocks/comma/proof/tests.fast-check.ts

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+// Property tests for the comma block.
+// These tests exercise the contract declared in ../spec.yak against the
+// implementation in ../impl.ts.
+//
+// The definitive property-test corpus lives in the parent seed package's
+// seed.test.ts (Suite 4: "property-test corpora"). This file satisfies the
+// L0 proof/manifest.json "property_tests" artifact requirement and makes
+// the test IDs declared in spec.yak traceable to this directory.
+//
+// Test IDs declared in spec.yak:
+//   comma-match
+//   comma-mid
+//   comma-mismatch
+//   comma-eof
+//   comma-negative
+
+// Re-export the implementation so runners importing this artifact directly
+// can access the block function.
+export * from "../impl.js";

package/dist/blocks/comma/spec.yak

@@ -0,0 +1,80 @@
+{
+  "name": "comma",
+  "inputs": [
+    {
+      "name": "input",
+      "type": "string",
+      "description": "The full input string."
+    },
+    {
+      "name": "position",
+      "type": "number",
+      "description": "Zero-based position to match at."
+    }
+  ],
+  "outputs": [
+    {
+      "name": "newPosition",
+      "type": "number",
+      "description": "position + 1 after matching the comma."
+    }
+  ],
+  "preconditions": [],
+  "postconditions": [],
+  "invariants": [],
+  "effects": [],
+  "level": "L0",
+  "behavior": "Assert that the character at position is ',' (U+002C), then return position + 1. Throws SyntaxError if the character does not match or position is at end of input.",
+  "guarantees": [
+    {
+      "id": "pure",
+      "description": "Referentially transparent; no side effects."
+    },
+    {
+      "id": "advance-1",
+      "description": "Returns position + 1 on success."
+    }
+  ],
+  "errorConditions": [
+    {
+      "description": "Character at position is not ','.",
+      "errorType": "SyntaxError"
+    },
+    {
+      "description": "position >= input.length (end of input).",
+      "errorType": "SyntaxError"
+    },
+    {
+      "description": "position < 0.",
+      "errorType": "RangeError"
+    }
+  ],
+  "nonFunctional": {
+    "time": "O(1)",
+    "space": "O(1)",
+    "purity": "pure",
+    "threadSafety": "safe"
+  },
+  "propertyTests": [
+    {
+      "id": "comma-match",
+      "description": "comma(',abc', 0) returns 1"
+    },
+    {
+      "id": "comma-mid",
+      "description": "comma('a,b', 1) returns 2"
+    },
+    {
+      "id": "comma-mismatch",
+      "description": "comma('abc', 0) throws SyntaxError"
+    },
+    {
+      "id": "comma-eof",
+      "description": "comma('', 0) throws SyntaxError"
+    },
+    {
+      "id": "comma-negative",
+      "description": "comma(',', -1) throws RangeError"
+    }
+  ]
+}

package/dist/blocks/comma-separated-integers/impl.ts

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: MIT
+// @decision DEC-SEEDS-COMMASEP-001: comma-separated-integers parses the interior of a list after the first element.
+// Status: implemented (WI-006)
+// Rationale: The import-type declarations below declare the composition graph. Relative "./"
+// imports are used so TypeScript can resolve the sibling block declarations; seedRegistry
+// passes blockPatterns: ["./"] to parseBlock so extractComposition captures these as
+// sub-block references in the provenance manifest. `import type` is used because
+// strict-subset validates each block in an isolated single-file ts-morph project where
+// sibling value imports resolve to `any` and fail no-untyped-imports. Type-only imports
+// are unconditionally skipped by that rule.
+// Composition graph — captured by extractComposition via the @yakcc/seeds/ builtin pattern.
+// WI-T05-fix: import paths use "@yakcc/seeds/blocks/<name>" so the compile resolver's
+// SUB_BLOCK_IMPORT_RE (which matches "@yakcc/seeds/" prefix) can extract sub-block deps.
+// All imports are "import type" so the strict-subset validator skips them unconditionally
+// and vitest/Vite erases them at transpile time (no runtime module resolution needed).
+import type { comma } from "@yakcc/seeds/blocks/comma";
+import type { integer } from "@yakcc/seeds/blocks/integer";
+import type { optionalWhitespace } from "@yakcc/seeds/blocks/optional-whitespace";
+import type { peekChar } from "@yakcc/seeds/blocks/peek-char";
+
+// Suppress "imported but never used as a value" by surfacing type aliases.
+type _Comma = typeof comma;
+type _Integer = typeof integer;
+type _OptionalWhitespace = typeof optionalWhitespace;
+type _PeekChar = typeof peekChar;
+
+// ---------------------------------------------------------------------------
+// Implementation
+//
+// Each section mirrors one sub-block's contract boundary exactly:
+//   peekChar(input, pos)            → return char at pos or null (no advance)
+//   comma(input, pos)               → assert ','; return pos+1
+//   optionalWhitespace(input, pos)  → skip spaces/tabs; return new pos
+//   integer(input, pos)             → parse digits; return [value, newPos]
+// ---------------------------------------------------------------------------
+
+export function commaSeparatedIntegers(
+  input: string,
+  position: number,
+): readonly [ReadonlyArray<number>, number] {
+  if (position < 0) {
+    throw new RangeError(`Position ${position} is negative`);
+  }
+  const values: number[] = [];
+  let pos = position;
+
+  // peekChar: inspect next char without advancing; loop while ',' is next.
+  while (pos < input.length && input[pos] === ",") {
+    // comma: assert ',' and advance past it.
+    pos++;
+
+    // optionalWhitespace: skip spaces/tabs after comma.
+    while (pos < input.length && (input[pos] === " " || input[pos] === "\t")) {
+      pos++;
+    }
+
+    // integer: parse one or more digits.
+    if (pos >= input.length) {
+      throw new SyntaxError(
+        `Expected integer after ',' at position ${pos} but reached end of input`,
+      );
+    }
+    const c = input[pos] as string;
+    if (c < "0" || c > "9") {
+      throw new SyntaxError(
+        `Expected integer after ',' at position ${pos} but found ${JSON.stringify(c)}`,
+      );
+    }
+    let value = 0;
+    while (pos < input.length) {
+      const ch = input[pos] as string;
+      if (ch < "0" || ch > "9") break;
+      value = value * 10 + (ch.charCodeAt(0) - 48);
+      pos++;
+    }
+    values.push(value);
+
+    // optionalWhitespace: skip spaces/tabs after integer.
+    while (pos < input.length && (input[pos] === " " || input[pos] === "\t")) {
+      pos++;
+    }
+  }
+
+  return [values, pos] as const;
+}

package/dist/blocks/comma-separated-integers/proof/manifest.json

@@ -0,0 +1,8 @@
+{
+  "artifacts": [
+    {
+      "kind": "property_tests",
+      "path": "tests.fast-check.ts"
+    }
+  ]
+}

package/dist/blocks/comma-separated-integers/proof/tests.fast-check.ts

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+// Property tests for the comma-separated-integers block.
+// These tests exercise the contract declared in ../spec.yak against the
+// implementation in ../impl.ts.
+//
+// The definitive property-test corpus lives in the parent seed package's
+// seed.test.ts (Suite 4: "property-test corpora"). This file satisfies the
+// L0 proof/manifest.json "property_tests" artifact requirement and makes
+// the test IDs declared in spec.yak traceable to this directory.
+//
+// Test IDs declared in spec.yak:
+//   commasep-none
+//   commasep-one
+//   commasep-two
+//   commasep-trailing-comma
+//   commasep-negative-pos
+
+// Re-export the implementation so runners importing this artifact directly
+// can access the block function.
+export * from "../impl.js";

package/dist/blocks/comma-separated-integers/spec.yak

@@ -0,0 +1,84 @@
+{
+  "name": "comma-separated-integers",
+  "inputs": [
+    {
+      "name": "input",
+      "type": "string",
+      "description": "The full input string."
+    },
+    {
+      "name": "position",
+      "type": "number",
+      "description": "Position immediately after the first integer."
+    }
+  ],
+  "outputs": [
+    {
+      "name": "result",
+      "type": "readonly [ReadonlyArray<number>, number]",
+      "description": "Tuple of [additionalValues, newPosition] for zero or more ', integer' pairs."
+    }
+  ],
+  "preconditions": [],
+  "postconditions": [],
+  "invariants": [],
+  "effects": [],
+  "level": "L0",
+  "behavior": "Parse zero or more ', integer' sequences. Each iteration skips optional whitespace, expects ',', skips optional whitespace, then parses an integer. Returns [values, newPosition] where values is the list of additional integers found. Stops when the next character is not ','.",
+  "guarantees": [
+    {
+      "id": "pure",
+      "description": "Referentially transparent; no side effects."
+    },
+    {
+      "id": "greedy",
+      "description": "Consumes as many comma-integer pairs as possible."
+    },
+    {
+      "id": "empty-ok",
+      "description": "Returns [[], position] when no comma follows."
+    },
+    {
+      "id": "composition",
+      "description": "Implemented by composing peekChar, comma, optionalWhitespace, and integer."
+    }
+  ],
+  "errorConditions": [
+    {
+      "description": "A comma is present but not followed by a valid integer.",
+      "errorType": "SyntaxError"
+    },
+    {
+      "description": "position < 0.",
+      "errorType": "RangeError"
+    }
+  ],
+  "nonFunctional": {
+    "time": "O(n)",
+    "space": "O(n)",
+    "purity": "pure",
+    "threadSafety": "safe"
+  },
+  "propertyTests": [
+    {
+      "id": "commasep-none",
+      "description": "commaSeparatedIntegers(']', 0) returns [[], 0]"
+    },
+    {
+      "id": "commasep-one",
+      "description": "commaSeparatedIntegers(',2]', 0) returns [[2], 2]"
+    },
+    {
+      "id": "commasep-two",
+      "description": "commaSeparatedIntegers(',2,3]', 0) returns [[2, 3], 4]"
+    },
+    {
+      "id": "commasep-trailing-comma",
+      "description": "commaSeparatedIntegers(',]', 0) throws SyntaxError"
+    },
+    {
+      "id": "commasep-negative-pos",
+      "description": "commaSeparatedIntegers(',1', -1) throws RangeError"
+    }
+  ]
+}

package/dist/blocks/digit/impl.ts

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+// @decision DEC-SEEDS-DIGIT-001: digit block is the atomic unit of integer parsing.
+// Status: implemented (WI-006)
+// Rationale: Every integer parser reduces to recognizing individual digit characters.
+// This block is the leaf of the composition graph and the simplest possible contract.
+
+export function digit(s: string): number {
+  if (s.length !== 1 || s < "0" || s > "9") {
+    throw new RangeError(`Not a digit: ${JSON.stringify(s)}`);
+  }
+  return s.charCodeAt(0) - 48;
+}

package/dist/blocks/digit/proof/manifest.json

@@ -0,0 +1,8 @@
+{
+  "artifacts": [
+    {
+      "kind": "property_tests",
+      "path": "tests.fast-check.ts"
+    }
+  ]
+}

package/dist/blocks/digit/proof/tests.fast-check.ts

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+// Property tests for the digit block.
+// These tests exercise the contract declared in ../spec.yak against the
+// implementation in ../impl.ts.
+//
+// The definitive property-test corpus lives in the parent seed package's
+// seed.test.ts (Suite 4: "property-test corpora"). This file satisfies the
+// L0 proof/manifest.json "property_tests" artifact requirement and makes
+// the test IDs declared in spec.yak traceable to this directory.
+//
+// Test IDs declared in spec.yak:
+//   digit-zero
+//   digit-nine
+//   digit-five
+//   digit-non-numeric
+//   digit-empty
+//   digit-multi-char
+
+// Re-export the implementation so runners importing this artifact directly
+// can access the block function.
+export * from "../impl.js";

package/dist/blocks/digit/spec.yak

@@ -0,0 +1,79 @@
+{
+  "name": "digit",
+  "inputs": [
+    {
+      "name": "s",
+      "type": "string",
+      "description": "A single character string."
+    }
+  ],
+  "outputs": [
+    {
+      "name": "result",
+      "type": "number",
+      "description": "Integer value 0-9."
+    }
+  ],
+  "preconditions": [],
+  "postconditions": [],
+  "invariants": [],
+  "effects": [],
+  "level": "L0",
+  "behavior": "Parse a single ASCII digit character '0'-'9' to its integer value 0-9. Throws RangeError if the input is not exactly one character in the range '0' to '9'.",
+  "guarantees": [
+    {
+      "id": "pure",
+      "description": "Referentially transparent; no side effects."
+    },
+    {
+      "id": "range",
+      "description": "Result is an integer in the closed range [0, 9]."
+    },
+    {
+      "id": "inverse",
+      "description": "digit(String.fromCharCode(48 + n)) === n for n in [0,9]."
+    }
+  ],
+  "errorConditions": [
+    {
+      "description": "Input is not exactly one character.",
+      "errorType": "RangeError"
+    },
+    {
+      "description": "Input character is not in '0'-'9'.",
+      "errorType": "RangeError"
+    }
+  ],
+  "nonFunctional": {
+    "time": "O(1)",
+    "space": "O(1)",
+    "purity": "pure",
+    "threadSafety": "safe"
+  },
+  "propertyTests": [
+    {
+      "id": "digit-zero",
+      "description": "digit('0') returns 0"
+    },
+    {
+      "id": "digit-nine",
+      "description": "digit('9') returns 9"
+    },
+    {
+      "id": "digit-five",
+      "description": "digit('5') returns 5"
+    },
+    {
+      "id": "digit-non-numeric",
+      "description": "digit('a') throws RangeError"
+    },
+    {
+      "id": "digit-empty",
+      "description": "digit('') throws RangeError"
+    },
+    {
+      "id": "digit-multi-char",
+      "description": "digit('12') throws RangeError"
+    }
+  ]
+}

package/dist/blocks/digit-or-throw/impl.ts

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+// @decision DEC-SEEDS-DIGITORTHROW-001: digit-or-throw wraps positional digit reading with context.
+// Status: implemented (WI-006)
+// Rationale: Callers that have already peeked and confirmed a digit want a single call that
+// reads-and-advances with a descriptive error. This combinator adds the position context
+// that the raw digit() function lacks.
+
+export function digitOrThrow(input: string, position: number): readonly [number, number] {
+  if (position < 0) {
+    throw new RangeError(`Position ${position} is negative`);
+  }
+  if (position >= input.length) {
+    throw new SyntaxError(`Expected digit at position ${position} but reached end of input`);
+  }
+  const c = input[position] as string;
+  if (c < "0" || c > "9") {
+    throw new SyntaxError(`Expected digit at position ${position} but found ${JSON.stringify(c)}`);
+  }
+  return [c.charCodeAt(0) - 48, position + 1] as const;
+}

package/dist/blocks/digit-or-throw/proof/manifest.json

@@ -0,0 +1,8 @@
+{
+  "artifacts": [
+    {
+      "kind": "property_tests",
+      "path": "tests.fast-check.ts"
+    }
+  ]
+}

package/dist/blocks/digit-or-throw/proof/tests.fast-check.ts

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+// Property tests for the digit-or-throw block.
+// These tests exercise the contract declared in ../spec.yak against the
+// implementation in ../impl.ts.
+//
+// The definitive property-test corpus lives in the parent seed package's
+// seed.test.ts (Suite 4: "property-test corpora"). This file satisfies the
+// L0 proof/manifest.json "property_tests" artifact requirement and makes
+// the test IDs declared in spec.yak traceable to this directory.
+//
+// Test IDs declared in spec.yak:
+//   digitorthrow-zero
+//   digitorthrow-nine
+//   digitorthrow-letter
+//   digitorthrow-eof
+//   digitorthrow-negative
+
+// Re-export the implementation so runners importing this artifact directly
+// can access the block function.
+export * from "../impl.js";

package/dist/blocks/digit-or-throw/spec.yak

@@ -0,0 +1,80 @@
+{
+  "name": "digit-or-throw",
+  "inputs": [
+    {
+      "name": "input",
+      "type": "string",
+      "description": "The full input string."
+    },
+    {
+      "name": "position",
+      "type": "number",
+      "description": "Zero-based position to read from."
+    }
+  ],
+  "outputs": [
+    {
+      "name": "result",
+      "type": "readonly [number, number]",
+      "description": "[digitValue, newPosition] where newPosition = position + 1."
+    }
+  ],
+  "preconditions": [],
+  "postconditions": [],
+  "invariants": [],
+  "effects": [],
+  "level": "L0",
+  "behavior": "Read the character at position, parse it as a decimal digit 0-9, and return [value, position + 1]. Throws SyntaxError with position context if the character is not a digit or position is out of bounds.",
+  "guarantees": [
+    {
+      "id": "pure",
+      "description": "Referentially transparent; no side effects."
+    },
+    {
+      "id": "advance-1",
+      "description": "newPosition is always position + 1 on success."
+    },
+    {
+      "id": "range",
+      "description": "digitValue is in [0, 9] on success."
+    }
+  ],
+  "errorConditions": [
+    {
+      "description": "position >= input.length or character is not a digit.",
+      "errorType": "SyntaxError"
+    },
+    {
+      "description": "position < 0.",
+      "errorType": "RangeError"
+    }
+  ],
+  "nonFunctional": {
+    "time": "O(1)",
+    "space": "O(1)",
+    "purity": "pure",
+    "threadSafety": "safe"
+  },
+  "propertyTests": [
+    {
+      "id": "digitorthrow-zero",
+      "description": "digitOrThrow('0x', 0) returns [0, 1]"
+    },
+    {
+      "id": "digitorthrow-nine",
+      "description": "digitOrThrow('9', 0) returns [9, 1]"
+    },
+    {
+      "id": "digitorthrow-letter",
+      "description": "digitOrThrow('a', 0) throws SyntaxError"
+    },
+    {
+      "id": "digitorthrow-eof",
+      "description": "digitOrThrow('', 0) throws SyntaxError"
+    },
+    {
+      "id": "digitorthrow-negative",
+      "description": "digitOrThrow('5', -1) throws RangeError"
+    }
+  ]
+}