@ojoxux/typecow 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 typecow contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,79 @@
+# typecow
+
+A type level interpreter for the esoteric programming language
+[COW](https://bigzaphod.github.io/COW/) written in TypeScript.
+
+The program is evaluated by the TypeScript compiler. The package contains no
+runtime interpreter.
+
+```ts
+import type { Cow } from "@ojoxux/typecow";
+
+type Program = "oom MoO OOM";
+type Input = "41\n";
+type Output = Cow<Program, Input>; // "42\n"
+```
+
+## Commands
+
+All twelve COW commands are implemented:
+
+| Command | Operation |
+| --- | --- |
+| `moo` | Search backward for the matching `MOO` |
+| `mOo` | Move the memory pointer left |
+| `moO` | Move the memory pointer right |
+| `mOO` | Execute the current cell as an opcode |
+| `Moo` | Read or write one ASCII character |
+| `MOo` | Decrement the current cell |
+| `MoO` | Increment the current cell |
+| `MOO` | Begin a loop |
+| `OOO` | Set the current cell to zero |
+| `MMM` | Copy through the register |
+| `OOM` | Write the current cell as a decimal integer |
+| `oom` | Read a decimal integer |
+
+Text that does not form a command is ignored.
+
+## Input and output
+
+`Moo` consumes one ASCII character when the current cell is zero. Otherwise it
+appends the ASCII character represented by the cell to the output.
+
+`oom` consumes a signed decimal integer through the next newline. `OOM` appends
+the decimal value followed by a newline.
+
+```ts
+type Echo = Cow<"Moo Moo", "A">; // "A"
+type AddOne = Cow<"oom MoO OOM", "-2\n">; // "-1\n"
+```
+
+Character I/O supports 7-bit ASCII. Integer cells are represented as signed
+unary tuples, so their practical range is limited by the TypeScript compiler's
+type-instantiation budget. This representation keeps increment, decrement,
+zero checks, dynamic dispatch, and decimal output predictable.
+
+Invalid programs and inputs produce a `CowError<...>` type.
+
+```ts
+import type { Cow, CowError } from "@ojoxux/typecow";
+
+type Error = Cow<"mOo">; // CowError<"memory-underflow">
+```
+
+## Development
+
+```sh
+npm install
+npm test
+npm run build
+```
+
+The recursive evaluator uses the same logarithmic recursion-flattening idea as
+[@susisu/typefuck](https://github.com/susisu/typefuck), which inspired this
+project.
+
+## License
+
+MIT. See [THIRD_PARTY_NOTICES.md](./THIRD_PARTY_NOTICES.md) for third-party
+copyright and license notices.

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,27 @@
+# Third-party notices
+
+typecowの再帰縮約を実装する`Recurse`と`RecurseSub`は、[@susisu/typefuck](https://github.com/susisu/typefuck)を翻案しています。
+
+## @susisu/typefuck
+
+The MIT License (http://opensource.org/licenses/mit-license.php)
+
+Copyright (c) 2020-2025 Susisu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/ascii.d.ts

@@ -0,0 +1,137 @@
+type AsciiCharacters = {
+    0: "\x00";
+    1: "\x01";
+    2: "\x02";
+    3: "\x03";
+    4: "\x04";
+    5: "\x05";
+    6: "\x06";
+    7: "\x07";
+    8: "\x08";
+    9: "\x09";
+    10: "\x0a";
+    11: "\x0b";
+    12: "\x0c";
+    13: "\x0d";
+    14: "\x0e";
+    15: "\x0f";
+    16: "\x10";
+    17: "\x11";
+    18: "\x12";
+    19: "\x13";
+    20: "\x14";
+    21: "\x15";
+    22: "\x16";
+    23: "\x17";
+    24: "\x18";
+    25: "\x19";
+    26: "\x1a";
+    27: "\x1b";
+    28: "\x1c";
+    29: "\x1d";
+    30: "\x1e";
+    31: "\x1f";
+    32: " ";
+    33: "!";
+    34: "\"";
+    35: "#";
+    36: "$";
+    37: "%";
+    38: "&";
+    39: "'";
+    40: "(";
+    41: ")";
+    42: "*";
+    43: "+";
+    44: ",";
+    45: "-";
+    46: ".";
+    47: "/";
+    48: "0";
+    49: "1";
+    50: "2";
+    51: "3";
+    52: "4";
+    53: "5";
+    54: "6";
+    55: "7";
+    56: "8";
+    57: "9";
+    58: ":";
+    59: ";";
+    60: "<";
+    61: "=";
+    62: ">";
+    63: "?";
+    64: "@";
+    65: "A";
+    66: "B";
+    67: "C";
+    68: "D";
+    69: "E";
+    70: "F";
+    71: "G";
+    72: "H";
+    73: "I";
+    74: "J";
+    75: "K";
+    76: "L";
+    77: "M";
+    78: "N";
+    79: "O";
+    80: "P";
+    81: "Q";
+    82: "R";
+    83: "S";
+    84: "T";
+    85: "U";
+    86: "V";
+    87: "W";
+    88: "X";
+    89: "Y";
+    90: "Z";
+    91: "[";
+    92: "\\";
+    93: "]";
+    94: "^";
+    95: "_";
+    96: "`";
+    97: "a";
+    98: "b";
+    99: "c";
+    100: "d";
+    101: "e";
+    102: "f";
+    103: "g";
+    104: "h";
+    105: "i";
+    106: "j";
+    107: "k";
+    108: "l";
+    109: "m";
+    110: "n";
+    111: "o";
+    112: "p";
+    113: "q";
+    114: "r";
+    115: "s";
+    116: "t";
+    117: "u";
+    118: "v";
+    119: "w";
+    120: "x";
+    121: "y";
+    122: "z";
+    123: "{";
+    124: "|";
+    125: "}";
+    126: "~";
+    127: "\x7f";
+};
+type BuildTuple<N extends number, Result extends unknown[] = []> = Result["length"] extends N ? Result : BuildTuple<N, [...Result, unknown]>;
+export type AsciiCharacter = AsciiCharacters[keyof AsciiCharacters];
+export type CharacterOf<Magnitude extends unknown[]> = Magnitude["length"] extends keyof AsciiCharacters ? AsciiCharacters[Magnitude["length"]] : never;
+export type MagnitudeOf<C> = {
+    [N in keyof AsciiCharacters]: AsciiCharacters[N] extends C ? BuildTuple<N & number> : never;
+}[keyof AsciiCharacters];
+export {};

package/dist/index.d.ts

@@ -0,0 +1,137 @@
+import type { AsciiCharacter, CharacterOf, MagnitudeOf } from "./ascii.js";
+type Opcode = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
+type Tokenize<Source extends string, Result extends Opcode[] = []> = Source extends `moo${infer Rest}` ? Tokenize<Rest, [...Result, 0]> : Source extends `mOo${infer Rest}` ? Tokenize<Rest, [...Result, 1]> : Source extends `moO${infer Rest}` ? Tokenize<Rest, [...Result, 2]> : Source extends `mOO${infer Rest}` ? Tokenize<Rest, [...Result, 3]> : Source extends `Moo${infer Rest}` ? Tokenize<Rest, [...Result, 4]> : Source extends `MOo${infer Rest}` ? Tokenize<Rest, [...Result, 5]> : Source extends `MoO${infer Rest}` ? Tokenize<Rest, [...Result, 6]> : Source extends `MOO${infer Rest}` ? Tokenize<Rest, [...Result, 7]> : Source extends `OOO${infer Rest}` ? Tokenize<Rest, [...Result, 8]> : Source extends `MMM${infer Rest}` ? Tokenize<Rest, [...Result, 9]> : Source extends `OOM${infer Rest}` ? Tokenize<Rest, [...Result, 10]> : Source extends `oom${infer Rest}` ? Tokenize<Rest, [...Result, 11]> : Source extends `${infer _Character}${infer Rest}` ? Tokenize<Rest, Result> : Result;
+type Positive = "+";
+type Negative = "-";
+type Sign = Positive | Negative;
+type Integer<S extends Sign, M extends unknown[]> = {
+    sign: S;
+    magnitude: M;
+};
+type Zero = Integer<Positive, []>;
+type Normalize<S extends Sign, M extends unknown[]> = M extends [] ? Zero : Integer<S, M>;
+type Increment<I> = I extends Integer<infer S, infer M extends unknown[]> ? S extends Positive ? Integer<Positive, [...M, unknown]> : M extends [unknown, ...infer Rest] ? Normalize<Negative, Rest> : never : never;
+type Decrement<I> = I extends Integer<infer S, infer M extends unknown[]> ? S extends Negative ? Integer<Negative, [...M, unknown]> : M extends [unknown, ...infer Rest] ? Normalize<Positive, Rest> : Integer<Negative, [unknown]> : never;
+type IsZero<I> = I extends Integer<infer _S, infer M> ? M extends [] ? true : false : false;
+type IntegerString<I> = I extends Integer<infer S, infer M extends unknown[]> ? S extends Negative ? `-${M["length"]}` : `${M["length"]}` : never;
+type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
+type DigitMagnitude<D extends Digit> = D extends "0" ? [] : D extends "1" ? [unknown] : D extends "2" ? [unknown, unknown] : D extends "3" ? [unknown, unknown, unknown] : D extends "4" ? [unknown, unknown, unknown, unknown] : D extends "5" ? [unknown, unknown, unknown, unknown, unknown] : D extends "6" ? [unknown, unknown, unknown, unknown, unknown, unknown] : D extends "7" ? [unknown, unknown, unknown, unknown, unknown, unknown, unknown] : D extends "8" ? [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown] : [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown];
+type MultiplyByTen<M extends unknown[]> = [
+    ...M,
+    ...M,
+    ...M,
+    ...M,
+    ...M,
+    ...M,
+    ...M,
+    ...M,
+    ...M,
+    ...M
+];
+type ParseMagnitude<Source extends string, Result extends unknown[] = []> = Source extends "" ? Result : Source extends `${infer D extends Digit}${infer Rest}` ? ParseMagnitude<Rest, [...MultiplyByTen<Result>, ...DigitMagnitude<D>]> : CowError<"invalid-integer-input">;
+type ParseInteger<Source extends string> = Source extends "" ? CowError<"invalid-integer-input"> : Source extends `-${infer Digits}` ? Digits extends "" ? CowError<"invalid-integer-input"> : ParseMagnitude<Digits> extends infer M ? M extends unknown[] ? Normalize<Negative, M> : M : never : Source extends `+${infer Digits}` ? Digits extends "" ? CowError<"invalid-integer-input"> : ParseMagnitude<Digits> extends infer M ? M extends unknown[] ? Normalize<Positive, M> : M : never : ParseMagnitude<Source> extends infer M ? M extends unknown[] ? Normalize<Positive, M> : M : never;
+type ReadLine<Source extends string, Line extends string = ""> = Source extends `\n${infer Rest}` ? [Line, Rest] : Source extends `${infer C}${infer Rest}` ? ReadLine<Rest, `${Line}${C}`> : [Line, ""];
+type Program<Left extends Opcode[], Current extends Opcode | null, Right extends Opcode[]> = {
+    left: Left;
+    current: Current;
+    right: Right;
+};
+type ProgramFrom<Ops extends Opcode[]> = Ops extends [infer Current extends Opcode, ...infer Right extends Opcode[]] ? Program<[], Current, Right> : Program<[], null, []>;
+type Advance<P> = P extends Program<infer Left extends Opcode[], infer Current extends Opcode, infer Right extends Opcode[]> ? Right extends [
+    infer Next extends Opcode,
+    ...infer Rest extends Opcode[]
+] ? Program<[Current, ...Left], Next, Rest> : Program<[Current, ...Left], null, []> : P;
+type Retreat<P> = P extends Program<infer Left extends Opcode[], infer Current extends Opcode | null, infer Right extends Opcode[]> ? Left extends [
+    infer Previous extends Opcode,
+    ...infer Rest extends Opcode[]
+] ? Current extends Opcode ? Program<Rest, Previous, [Current, ...Right]> : Program<Rest, Previous, Right> : CowError<"program-underflow"> : never;
+type Memory<Left extends Integer<Sign, unknown[]>[], Head extends Integer<Sign, unknown[]>, Right extends Integer<Sign, unknown[]>[]> = {
+    left: Left;
+    head: Head;
+    right: Right;
+};
+type InitialMemory = Memory<[], Zero, []>;
+type ReadMemory<M> = M extends Memory<infer _Left, infer Head, infer _Right> ? Head : never;
+type WriteMemory<M, Value extends Integer<Sign, unknown[]>> = M extends Memory<infer Left, infer _Head, infer Right> ? Memory<Left, Value, Right> : never;
+type MoveMemoryLeft<M> = M extends Memory<infer Left, infer Head, infer Right> ? Left extends [
+    infer Previous extends Integer<Sign, unknown[]>,
+    ...infer Rest extends Integer<Sign, unknown[]>[]
+] ? Memory<Rest, Previous, [Head, ...Right]> : CowError<"memory-underflow"> : never;
+type MoveMemoryRight<M> = M extends Memory<infer Left, infer Head, infer Right> ? Right extends [
+    infer Next extends Integer<Sign, unknown[]>,
+    ...infer Rest extends Integer<Sign, unknown[]>[]
+] ? Memory<[Head, ...Left], Next, Rest> : Memory<[Head, ...Left], Zero, []> : never;
+type Register = Integer<Sign, unknown[]> | null;
+type State<P, M, I extends string, O extends string, R extends Register> = {
+    program: P;
+    memory: M;
+    input: I;
+    output: O;
+    register: R;
+};
+type InitialState<Ops extends Opcode[], Input extends string> = State<ProgramFrom<Ops>, InitialMemory, Input, "", null>;
+export type CowError<Message extends string> = {
+    readonly error: Message;
+};
+type WithProgram<S, NextProgram> = S extends State<infer _Program, infer M, infer I, infer O, infer R> ? State<NextProgram, M, I, O, R> : never;
+type AdvanceState<S> = S extends State<infer P, infer M, infer I, infer O, infer R> ? State<Advance<P>, M, I, O, R> : never;
+type WithMemoryAndAdvance<S, NextMemory> = S extends State<infer P, infer _M, infer I, infer O, infer R> ? State<Advance<P>, NextMemory, I, O, R> : never;
+type ContinueBack<P, Depth extends unknown[]> = Retreat<P> extends infer Previous ? Previous extends CowError<string> ? CowError<"unmatched-moo"> : ScanBack<Previous, Depth> : never;
+type ScanBack<P, Depth extends unknown[]> = P extends Program<infer _Left, infer Current, infer _Right> ? Current extends 0 ? ContinueBack<P, [unknown, ...Depth]> : Current extends 7 ? Depth extends [unknown, ...infer Rest] ? Rest extends [] ? P : ContinueBack<P, Rest> : CowError<"unmatched-moo"> : ContinueBack<P, Depth> : CowError<"unmatched-moo">;
+type FindMatchingMooBack<P> = Retreat<P> extends infer Skipped ? Skipped extends CowError<string> ? CowError<"unmatched-moo"> : Retreat<Skipped> extends infer Candidate ? Candidate extends CowError<string> ? CowError<"unmatched-moo"> : ScanBack<Candidate, [unknown]> : never : never;
+type PopDepth<Depth extends unknown[]> = Depth extends [unknown, ...infer Rest] ? Rest : [];
+type CloseForwardDepth<Depth extends unknown[], Previous extends Opcode> = Previous extends 7 ? PopDepth<PopDepth<Depth>> : PopDepth<Depth>;
+type ContinueForward<P, Depth extends unknown[], Previous extends Opcode> = Advance<P> extends infer Next ? Next extends Program<infer _Left, infer Current, infer _Right> ? Current extends Opcode ? ScanForward<Next, Depth, Previous> : CowError<"unmatched-MOO"> : never : never;
+type ScanForward<P, Depth extends unknown[], Previous extends Opcode> = P extends Program<infer _Left, infer Current, infer _Right> ? Current extends Opcode ? Current extends 7 ? ContinueForward<P, [unknown, ...Depth], Current> : Current extends 0 ? CloseForwardDepth<Depth, Previous> extends infer NextDepth extends unknown[] ? NextDepth extends [] ? Advance<P> : ContinueForward<P, NextDepth, Current> : never : ContinueForward<P, Depth, Current> : CowError<"unmatched-MOO"> : CowError<"unmatched-MOO">;
+type FindAfterMatchingMoo<P> = Advance<P> extends infer Skipped ? Skipped extends Program<infer _Left, infer SkippedCurrent, infer _Right> ? SkippedCurrent extends Opcode ? Advance<Skipped> extends infer Candidate ? Candidate extends Program<infer _CandidateLeft, infer CandidateCurrent, infer _CandidateRight> ? CandidateCurrent extends Opcode ? ScanForward<Candidate, [unknown], SkippedCurrent> : CowError<"unmatched-MOO"> : never : never : CowError<"unmatched-MOO"> : never : never;
+type OpcodeFromInteger<I> = I extends Integer<Positive, infer M extends unknown[]> ? M["length"] extends Opcode ? M["length"] : never : never;
+type OutputCharacter<I> = I extends Integer<Positive, infer M extends unknown[]> ? CharacterOf<M> : never;
+type ExecuteMoo<S> = S extends State<infer P, infer _M, infer _I, infer _O, infer _R> ? FindMatchingMooBack<P> extends infer Target ? Target extends CowError<string> ? Target : Execute<7, WithProgram<S, Target>> : never : never;
+type ExecuteMoveLeft<S> = S extends State<infer _P, infer M, infer _I, infer _O, infer _R> ? MoveMemoryLeft<M> extends infer NextMemory ? NextMemory extends CowError<string> ? NextMemory : WithMemoryAndAdvance<S, NextMemory> : never : never;
+type ExecuteMoveRight<S> = S extends State<infer _P, infer M, infer _I, infer _O, infer _R> ? WithMemoryAndAdvance<S, MoveMemoryRight<M>> : never;
+type ExecuteDynamic<S> = S extends State<infer _P, infer M, infer _I, infer O, infer _R> ? OpcodeFromInteger<ReadMemory<M>> extends infer DynamicOpcode ? [DynamicOpcode] extends [never] ? O : DynamicOpcode extends 3 ? O : DynamicOpcode extends Opcode ? Execute<DynamicOpcode, S> : O : never : never;
+type ExecuteCharacterIO<S> = S extends State<infer P, infer M, infer I, infer O, infer R> ? IsZero<ReadMemory<M>> extends true ? I extends `${infer C}${infer Rest}` ? C extends AsciiCharacter ? State<Advance<P>, WriteMemory<M, Integer<Positive, MagnitudeOf<C>>>, Rest, O, R> : CowError<"non-ascii-character-input"> : CowError<"input-exhausted"> : OutputCharacter<ReadMemory<M>> extends infer C ? [C] extends [never] ? CowError<"non-ascii-character-output"> : C extends string ? State<Advance<P>, M, I, `${O}${C}`, R> : never : never : never;
+type ExecuteDecrement<S> = S extends State<infer _P, infer M, infer _I, infer _O, infer _R> ? WithMemoryAndAdvance<S, WriteMemory<M, Decrement<ReadMemory<M>>>> : never;
+type ExecuteIncrement<S> = S extends State<infer _P, infer M, infer _I, infer _O, infer _R> ? WithMemoryAndAdvance<S, WriteMemory<M, Increment<ReadMemory<M>>>> : never;
+type ExecuteMOO<S> = S extends State<infer P, infer M, infer _I, infer _O, infer _R> ? IsZero<ReadMemory<M>> extends true ? FindAfterMatchingMoo<P> extends infer Target ? Target extends CowError<string> ? Target : WithProgram<S, Target> : never : AdvanceState<S> : never;
+type ExecuteZero<S> = S extends State<infer _P, infer M, infer _I, infer _O, infer _R> ? WithMemoryAndAdvance<S, WriteMemory<M, Zero>> : never;
+type ExecuteRegister<S> = S extends State<infer P, infer M, infer I, infer O, infer R> ? R extends Integer<Sign, unknown[]> ? State<Advance<P>, WriteMemory<M, R>, I, O, null> : State<Advance<P>, M, I, O, ReadMemory<M>> : never;
+type ExecuteIntegerOutput<S> = S extends State<infer P, infer M, infer I, infer O, infer R> ? State<Advance<P>, M, I, `${O}${IntegerString<ReadMemory<M>>}\n`, R> : never;
+type ExecuteIntegerInput<S> = S extends State<infer P, infer M, infer I, infer O, infer R> ? ReadLine<I> extends [
+    infer Line extends string,
+    infer Rest extends string
+] ? ParseInteger<Line> extends infer Value ? Value extends CowError<string> ? Value : Value extends Integer<Sign, unknown[]> ? State<Advance<P>, WriteMemory<M, Value>, Rest, O, R> : never : never : never : never;
+type Execute<Op extends Opcode, S> = Op extends 0 ? ExecuteMoo<S> : Op extends 1 ? ExecuteMoveLeft<S> : Op extends 2 ? ExecuteMoveRight<S> : Op extends 3 ? ExecuteDynamic<S> : Op extends 4 ? ExecuteCharacterIO<S> : Op extends 5 ? ExecuteDecrement<S> : Op extends 6 ? ExecuteIncrement<S> : Op extends 7 ? ExecuteMOO<S> : Op extends 8 ? ExecuteZero<S> : Op extends 9 ? ExecuteRegister<S> : Op extends 10 ? ExecuteIntegerOutput<S> : ExecuteIntegerInput<S>;
+type Step<S> = S extends State<infer P, infer _M, infer _I, infer _O, infer _R> ? P extends Program<infer _Left, infer Current, infer _Right> ? Current extends Opcode ? Execute<Current, S> : S : never : S;
+/**
+ * Recursion compaction adapted from @susisu/typefuck.
+ * Copyright (c) 2020-2025 Susisu, licensed under the MIT License.
+ * See THIRD_PARTY_NOTICES.md for the complete notice.
+ */
+type Recurse<T> = T extends {
+    __rec: unknown;
+} ? Recurse<RecurseSub<T>> : T;
+type RecurseSub<T> = T extends {
+    __rec: never;
+} ? never : T extends {
+    __rec: {
+        __rec: infer U;
+    };
+} ? {
+    __rec: RecurseSub<U>;
+} : T extends {
+    __rec: infer U;
+} ? U : T;
+type Run<S> = Recurse<RunSub<S>>;
+type RunSub<S> = S extends CowError<string> ? S : S extends string ? S : S extends State<infer P, infer _M, infer _I, infer O, infer _R> ? P extends Program<infer _Left, infer Current, infer _Right> ? Current extends null ? O : {
+    __rec: RunSub<Step<S>>;
+} : never : never;
+/**
+ * Evaluates a COW program entirely in the TypeScript type system.
+ *
+ * `ProgramSource` may contain arbitrary comments. `Input` is a character
+ * stream for `Moo`; `oom` consumes a signed decimal integer through the next
+ * newline.
+ */
+export type Cow<ProgramSource extends string, Input extends string = ""> = ProgramSource extends unknown ? Input extends unknown ? Run<InitialState<Tokenize<ProgramSource>, Input>> : never : never;
+export {};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@ojoxux/typecow",
+  "version": "0.1.0",
+  "description": "A type-level COW interpreter in TypeScript",
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "THIRD_PARTY_NOTICES.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepack": "npm run build",
+    "test": "tsc -p tsconfig.test.json"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.2"
+  },
+  "license": "MIT"
+}