@yakcc/cli 0.5.0-alpha.0

package/dist/blocks/empty-list-content/impl.ts

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+// @decision DEC-SEEDS-EMPTYLIST-001: empty-list-content recognizes the ']' that closes an empty list.
+// Status: implemented (WI-006)
+// Rationale: Splitting empty vs nonempty list content into two blocks keeps each block's
+// contract minimal. list-of-ints dispatches based on the first character after '['.
+
+export function emptyListContent(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/empty-list-content/proof/manifest.json

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

package/dist/blocks/empty-list-content/proof/tests.fast-check.ts

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+// Property tests for the empty-list-content 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:
+//   empty-list-ok
+//   empty-list-mid
+//   empty-list-nonempty
+//   empty-list-eof
+//   empty-list-negative
+
+// Re-export the implementation so runners importing this artifact directly
+// can access the block function.
+export * from "../impl.js";

package/dist/blocks/empty-list-content/spec.yak

@@ -0,0 +1,80 @@
+{
+  "name": "empty-list-content",
+  "inputs": [
+    {
+      "name": "input",
+      "type": "string",
+      "description": "The full input string."
+    },
+    {
+      "name": "position",
+      "type": "number",
+      "description": "Position immediately after '['."
+    }
+  ],
+  "outputs": [
+    {
+      "name": "newPosition",
+      "type": "number",
+      "description": "Position after the closing ']'."
+    }
+  ],
+  "preconditions": [],
+  "postconditions": [],
+  "invariants": [],
+  "effects": [],
+  "level": "L0",
+  "behavior": "Assert that the character at position is ']', indicating an empty list. Returns position + 1. Throws SyntaxError if anything other than ']' is found.",
+  "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.",
+      "errorType": "SyntaxError"
+    },
+    {
+      "description": "position < 0.",
+      "errorType": "RangeError"
+    }
+  ],
+  "nonFunctional": {
+    "time": "O(1)",
+    "space": "O(1)",
+    "purity": "pure",
+    "threadSafety": "safe"
+  },
+  "propertyTests": [
+    {
+      "id": "empty-list-ok",
+      "description": "emptyListContent(']', 0) returns 1"
+    },
+    {
+      "id": "empty-list-mid",
+      "description": "emptyListContent('[]', 1) returns 2"
+    },
+    {
+      "id": "empty-list-nonempty",
+      "description": "emptyListContent('[1]', 1) throws SyntaxError"
+    },
+    {
+      "id": "empty-list-eof",
+      "description": "emptyListContent('', 0) throws SyntaxError"
+    },
+    {
+      "id": "empty-list-negative",
+      "description": "emptyListContent(']', -1) throws RangeError"
+    }
+  ]
+}

package/dist/blocks/eof-check/impl.ts

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+// @decision DEC-SEEDS-EOFCHECK-001: eof-check is the trailing-input rejection gate.
+// Status: implemented (WI-006)
+// Rationale: A parser that accepts input must also reject trailing garbage. This block
+// is the explicit end-of-input assertion that composition blocks call after parsing.
+
+export function eofCheck(input: string, position: number): void {
+  if (position > input.length) {
+    throw new RangeError(`Position ${position} overruns input of length ${input.length}`);
+  }
+  if (position < input.length) {
+    throw new SyntaxError(
+      `Expected end of input at position ${position} but found ${JSON.stringify(input.slice(position))}`,
+    );
+  }
+}

package/dist/blocks/eof-check/proof/manifest.json

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

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

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+// Property tests for the eof-check 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:
+//   eof-check-exact
+//   eof-check-trailing
+//   eof-check-overrun
+//   eof-check-empty
+//   eof-check-empty-nonzero
+
+// Re-export the implementation so runners importing this artifact directly
+// can access the block function.
+export * from "../impl.js";

package/dist/blocks/eof-check/spec.yak

@@ -0,0 +1,76 @@
+{
+  "name": "eof-check",
+  "inputs": [
+    {
+      "name": "input",
+      "type": "string",
+      "description": "The full input string."
+    },
+    {
+      "name": "position",
+      "type": "number",
+      "description": "Expected end position."
+    }
+  ],
+  "outputs": [
+    {
+      "name": "result",
+      "type": "void",
+      "description": "Returns undefined on success."
+    }
+  ],
+  "preconditions": [],
+  "postconditions": [],
+  "invariants": [],
+  "effects": [],
+  "level": "L0",
+  "behavior": "Assert that position equals input.length, indicating no trailing input remains. Throws SyntaxError if any input remains after position.",
+  "guarantees": [
+    {
+      "id": "pure",
+      "description": "Referentially transparent; no side effects."
+    },
+    {
+      "id": "exact",
+      "description": "Succeeds if and only if position === input.length."
+    }
+  ],
+  "errorConditions": [
+    {
+      "description": "position < input.length — trailing characters remain.",
+      "errorType": "SyntaxError"
+    },
+    {
+      "description": "position > input.length — position overran input.",
+      "errorType": "RangeError"
+    }
+  ],
+  "nonFunctional": {
+    "time": "O(1)",
+    "space": "O(1)",
+    "purity": "pure",
+    "threadSafety": "safe"
+  },
+  "propertyTests": [
+    {
+      "id": "eof-check-exact",
+      "description": "eofCheck('abc', 3) returns undefined"
+    },
+    {
+      "id": "eof-check-trailing",
+      "description": "eofCheck('abc', 2) throws SyntaxError"
+    },
+    {
+      "id": "eof-check-overrun",
+      "description": "eofCheck('abc', 4) throws RangeError"
+    },
+    {
+      "id": "eof-check-empty",
+      "description": "eofCheck('', 0) returns undefined"
+    },
+    {
+      "id": "eof-check-empty-nonzero",
+      "description": "eofCheck('', 1) throws RangeError"
+    }
+  ]
+}

package/dist/blocks/integer/impl.ts

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+// @decision DEC-SEEDS-INTEGER-001: integer composes digit; returns value + new position as a tuple.
+// Status: implemented (WI-006)
+// Rationale: Returning [value, newPosition] keeps the block pure while providing both the
+// parsed value and the advanced cursor to the caller without a mutable context object.
+
+export function integer(input: string, position: number): readonly [number, number] {
+  if (position < 0) {
+    throw new RangeError(`Position ${position} is negative`);
+  }
+  if (position >= input.length || input[position] === undefined) {
+    throw new SyntaxError(`Expected digit at position ${position} but reached end of input`);
+  }
+  const first = input[position] as string;
+  if (first < "0" || first > "9") {
+    throw new SyntaxError(
+      `Expected digit at position ${position} but found ${JSON.stringify(first)}`,
+    );
+  }
+  let value = 0;
+  let pos = position;
+  while (pos < input.length) {
+    const c = input[pos] as string;
+    if (c < "0" || c > "9") break;
+    value = value * 10 + (c.charCodeAt(0) - 48);
+    pos++;
+  }
+  return [value, pos] as const;
+}

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

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

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

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+// Property tests for the integer 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:
+//   integer-single
+//   integer-multi
+//   integer-mid
+//   integer-no-digit
+//   integer-eof
+//   integer-negative-pos
+
+// Re-export the implementation so runners importing this artifact directly
+// can access the block function.
+export * from "../impl.js";

package/dist/blocks/integer/spec.yak

@@ -0,0 +1,84 @@
+{
+  "name": "integer",
+  "inputs": [
+    {
+      "name": "input",
+      "type": "string",
+      "description": "The full input string."
+    },
+    {
+      "name": "position",
+      "type": "number",
+      "description": "Zero-based start position."
+    }
+  ],
+  "outputs": [
+    {
+      "name": "result",
+      "type": "readonly [number, number]",
+      "description": "[parsedValue, newPosition] tuple."
+    }
+  ],
+  "preconditions": [],
+  "postconditions": [],
+  "invariants": [],
+  "effects": [],
+  "level": "L0",
+  "behavior": "Parse a sequence of one or more ASCII decimal digits starting at position. Returns [value, newPosition] where value is the decimal integer and newPosition is one past the last digit. Throws SyntaxError if no digit is found at position.",
+  "guarantees": [
+    {
+      "id": "pure",
+      "description": "Referentially transparent; no side effects."
+    },
+    {
+      "id": "greedy",
+      "description": "Consumes as many digits as possible from position."
+    },
+    {
+      "id": "non-negative",
+      "description": "Parsed value is always >= 0."
+    }
+  ],
+  "errorConditions": [
+    {
+      "description": "No digit character found at position.",
+      "errorType": "SyntaxError"
+    },
+    {
+      "description": "position < 0.",
+      "errorType": "RangeError"
+    }
+  ],
+  "nonFunctional": {
+    "time": "O(n)",
+    "space": "O(1)",
+    "purity": "pure",
+    "threadSafety": "safe"
+  },
+  "propertyTests": [
+    {
+      "id": "integer-single",
+      "description": "integer('5', 0) returns [5, 1]"
+    },
+    {
+      "id": "integer-multi",
+      "description": "integer('123', 0) returns [123, 3]"
+    },
+    {
+      "id": "integer-mid",
+      "description": "integer('a42b', 1) returns [42, 3]"
+    },
+    {
+      "id": "integer-no-digit",
+      "description": "integer('abc', 0) throws SyntaxError"
+    },
+    {
+      "id": "integer-eof",
+      "description": "integer('', 0) throws SyntaxError"
+    },
+    {
+      "id": "integer-negative-pos",
+      "description": "integer('1', -1) throws RangeError"
+    }
+  ]
+}

package/dist/blocks/list-of-ints/impl.ts

@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: MIT
+// @decision DEC-SEEDS-LISTOFINTS-001: list-of-ints composes bracket/whitespace/nonempty/empty blocks.
+// Status: implemented (WI-006)
+// Rationale: This is the top-level compositor block. 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.
+// Because strict-subset validates each block in an isolated single-file ts-morph project,
+// `import type` is used — type-only imports are unconditionally skipped by no-untyped-imports.
+// 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 { bracket } from "@yakcc/seeds/blocks/bracket";
+import type { emptyListContent } from "@yakcc/seeds/blocks/empty-list-content";
+import type { eofCheck } from "@yakcc/seeds/blocks/eof-check";
+import type { nonAsciiRejector } from "@yakcc/seeds/blocks/non-ascii-rejector";
+import type { nonemptyListContent } from "@yakcc/seeds/blocks/nonempty-list-content";
+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.
+// These are type-level witnesses documenting which sub-block signatures are mirrored below.
+type _Bracket = typeof bracket;
+type _EmptyListContent = typeof emptyListContent;
+type _EofCheck = typeof eofCheck;
+type _NonAsciiRejector = typeof nonAsciiRejector;
+type _NonemptyListContent = typeof nonemptyListContent;
+type _OptionalWhitespace = typeof optionalWhitespace;
+type _PeekChar = typeof peekChar;
+
+// ---------------------------------------------------------------------------
+// Implementation
+//
+// Each section mirrors one sub-block's contract boundary exactly:
+//   nonAsciiRejector(input)               → scan all chars; throw RangeError on code > 127
+//   bracket(input, pos, '[')              → assert '[' at pos; return pos+1
+//   optionalWhitespace(input, pos)        → skip spaces/tabs; return new pos
+//   peekChar(input, pos)                  → return char at pos or null (no advance)
+//   emptyListContent(input, pos)          → assert ']'; return pos+1
+//   nonemptyListContent(input, pos)       → parse ints+commas+']'; return [values, newPos]
+//   eofCheck(input, pos)                  → assert pos === input.length
+// ---------------------------------------------------------------------------
+
+export function listOfInts(input: string): ReadonlyArray<number> {
+  // nonAsciiRejector: scan full input; throw RangeError on first code > 127.
+  for (let i = 0; i < input.length; i++) {
+    if (input.charCodeAt(i) > 127) {
+      throw new RangeError(`Non-ASCII character at position ${i}: code ${input.charCodeAt(i)}`);
+    }
+  }
+
+  // bracket(input, 0, '['): assert '[' at position 0.
+  if (input.length === 0 || input[0] !== "[") {
+    throw new SyntaxError(
+      `Expected '[' at position 0 but found ${JSON.stringify(input[0] ?? "EOF")}`,
+    );
+  }
+  let pos = 1;
+
+  // optionalWhitespace(input, pos): skip spaces/tabs after '['.
+  while (pos < input.length && (input[pos] === " " || input[pos] === "\t")) {
+    pos++;
+  }
+
+  // peekChar(input, pos): inspect next character without advancing.
+  const next = pos < input.length ? input[pos] : null;
+
+  let values: ReadonlyArray<number>;
+  if (next === "]") {
+    // emptyListContent(input, pos): assert ']', return pos+1.
+    pos++;
+    values = [] as const;
+  } else {
+    // nonemptyListContent(input, pos): parse one or more comma-separated ints + closing ']'.
+    const result = _nonemptyListContent(input, pos);
+    values = result[0];
+    pos = result[1];
+  }
+
+  // eofCheck(input, pos): assert pos === input.length.
+  if (pos > input.length) {
+    throw new RangeError(`Position ${pos} overruns input of length ${input.length}`);
+  }
+  if (pos < input.length) {
+    throw new SyntaxError(
+      `Expected end of input at position ${pos} but found ${JSON.stringify(input.slice(pos))}`,
+    );
+  }
+
+  return values;
+}
+
+// ---------------------------------------------------------------------------
+// Internal: nonemptyListContent sub-block (mirrors nonempty-list-content.ts contract)
+// ---------------------------------------------------------------------------
+
+function _nonemptyListContent(
+  input: string,
+  position: number,
+): readonly [ReadonlyArray<number>, number] {
+  const values: number[] = [];
+  let pos = position;
+
+  // optionalWhitespace: skip leading spaces/tabs.
+  while (pos < input.length && (input[pos] === " " || input[pos] === "\t")) {
+    pos++;
+  }
+
+  // integer: parse first integer (one or more digits required).
+  if (pos >= input.length || (input[pos] as string) < "0" || (input[pos] as string) > "9") {
+    throw new SyntaxError(
+      `Expected digit at position ${pos} but found ${JSON.stringify(input[pos] ?? "EOF")}`,
+    );
+  }
+  let first = 0;
+  while (pos < input.length) {
+    const c = input[pos] as string;
+    if (c < "0" || c > "9") break;
+    first = first * 10 + (c.charCodeAt(0) - 48);
+    pos++;
+  }
+  values.push(first);
+
+  // optionalWhitespace: skip whitespace after first integer.
+  while (pos < input.length && (input[pos] === " " || input[pos] === "\t")) {
+    pos++;
+  }
+
+  // commaSeparatedIntegers: loop over ", integer" pairs.
+  while (pos < input.length && input[pos] === ",") {
+    // comma: consume ','.
+    pos++;
+    // optionalWhitespace: skip after comma.
+    while (pos < input.length && (input[pos] === " " || input[pos] === "\t")) {
+      pos++;
+    }
+    // integer: parse next integer.
+    if (pos >= input.length || (input[pos] as string) < "0" || (input[pos] as string) > "9") {
+      throw new SyntaxError(
+        `Expected digit after ',' at position ${pos} but found ${JSON.stringify(input[pos] ?? "EOF")}`,
+      );
+    }
+    let val = 0;
+    while (pos < input.length) {
+      const c = input[pos] as string;
+      if (c < "0" || c > "9") break;
+      val = val * 10 + (c.charCodeAt(0) - 48);
+      pos++;
+    }
+    values.push(val);
+    // optionalWhitespace: skip after integer.
+    while (pos < input.length && (input[pos] === " " || input[pos] === "\t")) {
+      pos++;
+    }
+  }
+
+  // bracket(input, pos, ']'): expect closing ']'.
+  if (pos >= input.length || input[pos] !== "]") {
+    throw new SyntaxError(
+      `Expected ']' at position ${pos} but found ${JSON.stringify(input[pos] ?? "EOF")}`,
+    );
+  }
+  pos++;
+
+  return [values, pos] as const;
+}

package/dist/blocks/list-of-ints/proof/manifest.json

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

package/dist/blocks/list-of-ints/proof/tests.fast-check.ts

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+// Property tests for the list-of-ints 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:
+//   list-empty
+//   list-single
+//   list-multiple
+//   list-spaces
+//   list-incomplete
+//   list-non-digit
+//   list-no-open
+//   list-trailing
+
+// Re-export the implementation so runners importing this artifact directly
+// can access the block function.
+export * from "../impl.js";