langsagne 0.1.0

package/README.md

@@ -0,0 +1,158 @@
+# langsagne
+> Minimal programming language parser and execution experiment
+
+## Play
+
+```sh
+bun run test
+bun run exec examples/assignment
+bun run exec -- --trace examples/loop
+bun run exec -- --step examples/if-else
+```
+
+Programs live in `examples/`. Use Enter or `n` for next, `p` for previous, and `q` to quit in step mode.
+
+## Language
+
+### Syntax
+
+- numbers: `1`, `42`
+- strings: `"hello"`, `'path/to/file'`
+- variables: `a`, `count_1`
+- assignment: `a = 1 + 2`
+- arithmetic: `+`, `-`, `*`, `/` (numeric only)
+- comparison: `<` (returns `1` or `0`)
+- parentheses: `(1 + 2) * 3`
+- blocks: `{ ... }`
+- `if (expr) { ... } else { ... }`
+- `while (expr) { ... }`
+- `fn name(a, b) { ... }`
+- `return expr;`
+- function calls: `add(1, 2)`
+- statements end with `;`
+- last expression value is the program result
+
+Not supported yet: string `+`, `==`, arrays, comments, forward references.
+
+### System calls
+
+| Call | Args | Result |
+| --- | --- | --- |
+| `print(...)` | zero or more expressions | prints to stdout, leaves last arg in `ax` |
+| `assert(expr)` | one expression | throws if falsy |
+| `clock()` | none | `Date.now()` |
+
+Functions must be declared before use. Calls check arity (`add(1)` is an error).
+
+## Examples
+
+<details>
+<summary>Assignment and arithmetic</summary>
+
+```js
+a = 1;
+b = 2 + a;
+b;
+```
+
+```
+→ 3
+```
+
+</details>
+
+<details>
+<summary>Loop</summary>
+
+```js
+i = 0;
+sum = 0;
+while (i < 2) {
+  sum = sum + i;
+  i = i + 1;
+}
+sum;
+```
+
+```
+→ 1
+```
+
+</details>
+
+<details>
+<summary>If / else and multi-arg print</summary>
+
+```js
+value = 0;
+if (value) {
+  result = 1;
+} else {
+  result = 2;
+}
+print('result =', result);
+result;
+```
+
+```
+→ prints: result = 2
+→ returns: 2
+```
+
+</details>
+
+<details>
+<summary>Functions</summary>
+
+```js
+fn add(a, b) {
+  return a + b;
+}
+add(1, 2);
+```
+
+```
+→ 3
+```
+
+</details>
+
+<details>
+<summary>Failed assertion</summary>
+
+```js
+assert(1);
+assert(1 + 2 < 4);
+assert(2 + 2 < 4);
+```
+
+```
+→ RUNTIME ERR: assert failed
+   at line 3
+```
+
+</details>
+
+## API
+
+```ts
+import { execute } from './src/index.ts'
+
+execute('a = 1; b = a + 2; b;') // 3
+```
+
+`execute(code)` compiles and runs source, then returns the final value in `ax`.
+
+For directive-level debugging:
+
+```ts
+import { inspect } from './src/index.ts'
+
+const { directives, trace, result } = inspect('a = 1; a;')
+```
+
+Runtime code is under `src/` (`lexer/`, `compiler/`, `runtime/`, `debug/`). Tests are in `test/`.
+
+## Plan
+
+See [docs/design.md](docs/design.md) for the current gaps between this project and the c4-inspired language target.

package/dist/index.js

@@ -0,0 +1,715 @@
+// src/lexer/source.ts
+var i = 0;
+var line = 1;
+var column = 1;
+var str = "";
+var Source = {
+  get line() {
+    return line;
+  },
+  get column() {
+    return column;
+  },
+  get val() {
+    return str[i];
+  },
+  read() {
+    const ch = str[i++];
+    if (ch === `
+`) {
+      line += 1;
+      column = 1;
+    } else {
+      column += 1;
+    }
+    return ch;
+  },
+  eof: () => i === str.length,
+  initialize(text) {
+    str = text;
+    i = 0;
+    line = 1;
+    column = 1;
+  }
+};
+
+// src/lexer/token-state.ts
+var TokenState = {
+  token: null,
+  value: null,
+  startLine: 1,
+  startColumn: 1,
+  length: 0,
+  reset() {
+    TokenState.token = null;
+    TokenState.value = null;
+    TokenState.startLine = 1;
+    TokenState.startColumn = 1;
+    TokenState.length = 0;
+  }
+};
+
+// src/lexer/token-kind.ts
+var tokenKindLabels = new Map;
+var TokenKind = {
+  Number: 1,
+  Identifier: 2,
+  String: 3,
+  Else: 4,
+  If: 5,
+  Function: 6,
+  Return: 7,
+  While: 8,
+  Assign: 9,
+  LessThan: 10,
+  Add: 11,
+  Subtract: 12,
+  Multiply: 13,
+  Divide: 14,
+  label(value) {
+    return tokenKindLabels.get(value);
+  }
+};
+for (const [name, value] of Object.entries(TokenKind)) {
+  if (typeof value === "number")
+    tokenKindLabels.set(value, name);
+}
+
+// src/lexer/tokenize.ts
+function isDigit(chr) {
+  return chr != null && chr >= "0" && chr <= "9";
+}
+function isAlpha(chr) {
+  return chr != null && (chr >= "a" && chr <= "z" || chr >= "A" && chr <= "Z");
+}
+function setToken(token, value = null) {
+  TokenState.token = token;
+  TokenState.value = value;
+}
+function finishToken(startLine, startColumn) {
+  TokenState.startLine = startLine;
+  TokenState.startColumn = startColumn;
+  TokenState.length = Math.max(1, Source.column - startColumn);
+}
+function next() {
+  while (!Source.eof()) {
+    const startLine = Source.line;
+    const startColumn = Source.column;
+    const ch = Source.read();
+    if (isDigit(ch)) {
+      let value = +ch;
+      while (isDigit(Source.val)) {
+        value = value * 10 + +Source.read();
+      }
+      setToken(TokenKind.Number, value);
+      finishToken(startLine, startColumn);
+      return TokenState;
+    }
+    if (ch === '"' || ch === "'") {
+      let value = "";
+      while (!Source.eof() && Source.val !== ch) {
+        value += Source.read();
+      }
+      Source.read();
+      setToken(TokenKind.String, value);
+      finishToken(startLine, startColumn);
+      return TokenState;
+    }
+    if (isAlpha(ch) || ch === "_") {
+      let ident = ch;
+      while (isAlpha(Source.val) || Source.val === "_" || isDigit(Source.val)) {
+        ident += Source.read();
+      }
+      if (ident === "while")
+        setToken(TokenKind.While);
+      else if (ident === "if")
+        setToken(TokenKind.If);
+      else if (ident === "else")
+        setToken(TokenKind.Else);
+      else if (ident === "fn")
+        setToken(TokenKind.Function);
+      else if (ident === "return")
+        setToken(TokenKind.Return);
+      else
+        setToken(TokenKind.Identifier, ident);
+      finishToken(startLine, startColumn);
+      return TokenState;
+    }
+    if (ch === "+") {
+      setToken(TokenKind.Add);
+      finishToken(startLine, startColumn);
+      return TokenState;
+    }
+    if (ch === "-") {
+      setToken(TokenKind.Subtract);
+      finishToken(startLine, startColumn);
+      return TokenState;
+    }
+    if (ch === "*") {
+      setToken(TokenKind.Multiply);
+      finishToken(startLine, startColumn);
+      return TokenState;
+    }
+    if (ch === "/") {
+      setToken(TokenKind.Divide);
+      finishToken(startLine, startColumn);
+      return TokenState;
+    }
+    if (ch === "=") {
+      setToken(TokenKind.Assign);
+      finishToken(startLine, startColumn);
+      return TokenState;
+    }
+    if (ch === "<") {
+      setToken(TokenKind.LessThan);
+      finishToken(startLine, startColumn);
+      return TokenState;
+    }
+    if (ch === "(" || ch === ")" || ch === "{" || ch === "}" || ch === ";" || ch === ",") {
+      setToken(ch);
+      finishToken(startLine, startColumn);
+      return TokenState;
+    }
+  }
+  return TokenState;
+}
+
+// src/runtime/directive.ts
+var Directive = {
+  CONST: "CONST",
+  LOAD: "LOAD",
+  STORE: "STORE",
+  PUSH: "PUSH",
+  JMP: "JMP",
+  BZ: "BZ",
+  ADD: "ADD",
+  SUB: "SUB",
+  MUL: "MUL",
+  DIV: "DIV",
+  LT: "LT",
+  PRINT: "PRINT",
+  ASSERT: "ASSERT",
+  CLOCK: "CLOCK",
+  CALL: "CALL",
+  RET: "RET",
+  EXIT: "EXIT"
+};
+
+// src/runtime/storage.ts
+var Store = {
+  ax: 0,
+  pc: 0,
+  vs: [],
+  env: new Map,
+  fns: new Map,
+  cs: [],
+  reset() {
+    this.ax = 0;
+    this.pc = 0;
+    this.vs = [];
+    this.env = new Map;
+    this.fns = new Map;
+    this.cs = [];
+  }
+};
+
+// src/error.ts
+class LangError extends Error {
+  scope;
+  detail;
+  sourceLine;
+  pc = null;
+  constructor(scope, detail, sourceLine = null) {
+    super(`${scope} ERR: ${detail}`);
+    this.scope = scope;
+    this.detail = detail;
+    this.sourceLine = sourceLine;
+    this.name = "LangError";
+  }
+}
+function error(scope, message, sourceLine = null) {
+  throw new LangError(scope, message, sourceLine);
+}
+
+// src/runtime/vm.ts
+var directiveOperands = {
+  [Directive.CONST]: 1,
+  [Directive.LOAD]: 1,
+  [Directive.STORE]: 1,
+  [Directive.JMP]: 1,
+  [Directive.BZ]: 1,
+  [Directive.CALL]: 2,
+  [Directive.PRINT]: 1
+};
+function numberValue(value) {
+  return Number(value);
+}
+function popNumber() {
+  return numberValue(Store.vs.pop());
+}
+function currentFrame() {
+  const index = Store.cs.length - 1;
+  if (index < 0)
+    return null;
+  return Store.cs[index];
+}
+function snapshotEnv() {
+  const env = Object.fromEntries(Store.env);
+  const frame = currentFrame();
+  if (frame !== null) {
+    for (const [key, value] of frame.locals) {
+      env[key] = value;
+    }
+  }
+  return env;
+}
+function snapshot(pc = Store.pc) {
+  return {
+    pc,
+    ax: Store.ax,
+    vs: [...Store.vs],
+    env: snapshotEnv()
+  };
+}
+function execute(text, shouldTrace) {
+  Store.pc = 0;
+  const trace = [];
+  let op;
+  while (true) {
+    const pc = Store.pc;
+    const before = snapshot(pc);
+    op = text[Store.pc++];
+    if (op == null)
+      break;
+    const operandCount = typeof op === "string" ? directiveOperands[op] ?? 0 : 0;
+    const operands = text.slice(Store.pc, Store.pc + operandCount);
+    if (op === Directive.CONST) {
+      Store.ax = text[Store.pc++];
+    } else if (op === Directive.LOAD) {
+      const name = String(text[Store.pc++]);
+      const frame = currentFrame();
+      if (frame !== null && frame.locals.has(name)) {
+        Store.ax = frame.locals.get(name);
+      } else {
+        Store.ax = Store.env.get(name);
+      }
+    } else if (op === Directive.STORE) {
+      const name = String(text[Store.pc++]);
+      const frame = currentFrame();
+      if (frame !== null) {
+        frame.locals.set(name, Store.ax);
+      } else {
+        Store.env.set(name, Store.ax);
+      }
+    } else if (op === Directive.PUSH) {
+      Store.vs.push(Store.ax);
+    } else if (op === Directive.JMP) {
+      Store.pc = Number(text[Store.pc]);
+    } else if (op === Directive.BZ) {
+      const target = Number(text[Store.pc++]);
+      if (!Store.ax)
+        Store.pc = target;
+    } else if (op === Directive.ADD) {
+      Store.ax = popNumber() + numberValue(Store.ax);
+    } else if (op === Directive.SUB) {
+      Store.ax = popNumber() - numberValue(Store.ax);
+    } else if (op === Directive.MUL) {
+      Store.ax = popNumber() * numberValue(Store.ax);
+    } else if (op === Directive.DIV) {
+      Store.ax = popNumber() / numberValue(Store.ax);
+    } else if (op === Directive.LT) {
+      Store.ax = popNumber() < numberValue(Store.ax) ? 1 : 0;
+    } else if (op === Directive.PRINT) {
+      const argc = Number(text[Store.pc++]);
+      if (argc > 0) {
+        const args = Store.vs.splice(-argc, argc);
+        console.log(...args);
+      } else {
+        console.log();
+      }
+    } else if (op === Directive.ASSERT) {
+      if (!Store.ax)
+        error("RUNTIME", "assert failed", directiveSites.get(pc)?.line ?? null);
+    } else if (op === Directive.CLOCK) {
+      Store.ax = Date.now();
+    } else if (op === Directive.CALL) {
+      const name = String(text[Store.pc++]);
+      const argc = Number(text[Store.pc++]);
+      const fn = Store.fns.get(name) ?? error("RUNTIME", `unknown function ${name}`, directiveSites.get(pc)?.line ?? null);
+      if (argc !== fn.params.length) {
+        error("RUNTIME", `${name} expected ${fn.params.length} args but got ${argc}`, directiveSites.get(pc)?.line ?? null);
+      }
+      const locals = new Map;
+      for (let index = fn.params.length - 1;index >= 0; index -= 1) {
+        const param = fn.params[index];
+        const value = Store.vs.pop();
+        locals.set(param, value);
+      }
+      Store.cs.push({ ret: Store.pc, locals });
+      Store.pc = fn.entry;
+    } else if (op === Directive.RET) {
+      const frame = Store.cs.pop() ?? error("RUNTIME", "RET without call frame", directiveSites.get(pc)?.line ?? null);
+      Store.pc = frame.ret;
+    } else if (op === Directive.EXIT) {
+      if (shouldTrace)
+        trace.push(traceStep(pc, op, operands, before));
+      break;
+    } else {
+      break;
+    }
+    if (shouldTrace)
+      trace.push(traceStep(pc, op, operands, before));
+  }
+  return trace;
+}
+var directiveItems = [];
+var directiveSites = new Map;
+function traceStep(pc, op, operands, before) {
+  const site = directiveSites.get(pc) ?? null;
+  return {
+    pc,
+    op,
+    operands,
+    sourceLine: site?.line ?? null,
+    sourceColumn: site?.column ?? null,
+    sourceLength: site?.length ?? null,
+    before,
+    after: snapshot()
+  };
+}
+var VM = {
+  directives: () => Object.freeze(directiveItems),
+  emit: (...items) => {
+    directiveItems.push(...items);
+  },
+  emitAll: (items) => {
+    directiveItems.push(...items);
+  },
+  execute: () => execute(directiveItems, false),
+  patch: (index, value) => {
+    directiveItems[index] = value;
+  },
+  pop: () => directiveItems.pop(),
+  position: () => directiveItems.length,
+  mark: (line2, column2, length) => {
+    directiveSites.set(directiveItems.length, { line: line2, column: column2, length });
+  },
+  registerFn: (name, params, entry) => {
+    Store.fns.set(name, { entry, params });
+  },
+  reset: () => {
+    directiveItems = [];
+    directiveSites = new Map;
+  },
+  trace: () => execute(directiveItems, true)
+};
+
+// src/compiler/parse.ts
+function emit(...items) {
+  VM.mark(TokenState.startLine, TokenState.startColumn, TokenState.length);
+  VM.emit(...items);
+}
+function expect(expected) {
+  if (TokenState.token !== expected) {
+    const actual = typeof TokenState.token === "number" ? TokenKind.label(TokenState.token) : TokenState.token;
+    error("PARSE", `expected ${expected} but get ${actual}`);
+  }
+}
+function token() {
+  return TokenState.token;
+}
+function param() {
+  expect(TokenKind.Identifier);
+  const name = String(TokenState.value);
+  next();
+  return name;
+}
+function paramList() {
+  const params = [];
+  expect("(");
+  next();
+  if (TokenState.token !== ")") {
+    params.push(param());
+    while (TokenState.token === ",") {
+      next();
+      params.push(param());
+    }
+  }
+  expect(")");
+  next();
+  return params;
+}
+function argList() {
+  let argc = 0;
+  expect("(");
+  next();
+  if (TokenState.token !== ")") {
+    expr(TokenKind.Assign);
+    argc += 1;
+    while (TokenState.token === ",") {
+      next();
+      emit(Directive.PUSH);
+      expr(TokenKind.Assign);
+      argc += 1;
+    }
+  }
+  expect(")");
+  next();
+  if (argc > 0) {
+    emit(Directive.PUSH);
+  }
+  return argc;
+}
+function emptyArgList() {
+  expect("(");
+  next();
+  expect(")");
+  next();
+}
+function fnDecl() {
+  expect(TokenKind.Function);
+  next();
+  if (TokenState.token !== TokenKind.Identifier)
+    error("PARSE", "expected function name");
+  const name = String(TokenState.value);
+  next();
+  const params = paramList();
+  emit(Directive.JMP);
+  const skipTarget = VM.position();
+  emit(null);
+  const fnStart = VM.position();
+  VM.registerFn(name, params, fnStart);
+  block();
+  VM.patch(skipTarget, VM.position());
+}
+function statement() {
+  if (!TokenState.token && !Source.eof())
+    next();
+  if (!Source.eof() && TokenState.token === TokenKind.If) {
+    next();
+    expect("(");
+    next();
+    expr(TokenKind.Assign);
+    expect(")");
+    next();
+    emit(Directive.BZ);
+    const elseTarget = VM.position();
+    emit(null);
+    block();
+    if (TokenState.token === TokenKind.Else) {
+      emit(Directive.JMP);
+      const endTarget = VM.position();
+      emit(null);
+      VM.patch(elseTarget, VM.position());
+      next();
+      block();
+      VM.patch(endTarget, VM.position());
+    } else {
+      VM.patch(elseTarget, VM.position());
+    }
+  } else if (!Source.eof() && TokenState.token === TokenKind.While) {
+    next();
+    expect("(");
+    next();
+    const loopStart = VM.position();
+    expr(TokenKind.Assign);
+    expect(")");
+    next();
+    emit(Directive.BZ);
+    const exitTarget = VM.position();
+    emit(null);
+    block();
+    emit(Directive.JMP, loopStart);
+    VM.patch(exitTarget, VM.position());
+  } else if (TokenState.token === TokenKind.Return) {
+    next();
+    if (token() !== ";" && token() !== "}") {
+      expr(TokenKind.Assign);
+    }
+    emit(Directive.RET);
+    if (token() === ";") {
+      next();
+    }
+  } else if (TokenState.token === "{") {
+    block();
+  } else if (TokenState.token === ";") {
+    next();
+  } else {
+    expr(TokenKind.Assign);
+    if (TokenState.token === ";") {
+      next();
+    } else {
+      error("PARSE", `expected ; but get ${TokenKind.label(TokenState.token)}`);
+    }
+  }
+}
+function block() {
+  expect("{");
+  next();
+  while (!Source.eof() && TokenState.token !== "}") {
+    statement();
+  }
+  expect("}");
+  next();
+}
+function expr(level = 0) {
+  if (Source.eof())
+    return;
+  if (TokenState.token === TokenKind.Number) {
+    emit(Directive.CONST, TokenState.value);
+    next();
+  } else if (TokenState.token === TokenKind.String) {
+    emit(Directive.CONST, TokenState.value);
+    next();
+  } else if (TokenState.token === "(") {
+    expect("(");
+    next();
+    expr(TokenKind.Assign);
+    expect(")");
+    next();
+  } else if (TokenState.token === TokenKind.Identifier) {
+    const ident = String(TokenState.value);
+    next();
+    if (TokenState.token === "(") {
+      if (ident === "print") {
+        const argc = argList();
+        emit(Directive.PRINT, argc);
+      } else if (ident === "assert") {
+        expect("(");
+        next();
+        expr(TokenKind.Assign);
+        expect(")");
+        next();
+        emit(Directive.ASSERT);
+      } else if (ident === "clock") {
+        emptyArgList();
+        emit(Directive.CLOCK);
+      } else {
+        const argc = argList();
+        emit(Directive.CALL, ident, argc);
+      }
+    } else {
+      emit(Directive.LOAD, ident);
+    }
+  }
+  while (TokenState.token >= level) {
+    if (TokenState.token === TokenKind.Add) {
+      next();
+      emit(Directive.PUSH);
+      expr(TokenKind.Multiply);
+      emit(Directive.ADD);
+    } else if (TokenState.token === TokenKind.Subtract) {
+      next();
+      emit(Directive.PUSH);
+      expr(TokenKind.Multiply);
+      emit(Directive.SUB);
+    } else if (TokenState.token === TokenKind.Multiply) {
+      next();
+      emit(Directive.PUSH);
+      expr(TokenKind.Multiply + 1);
+      emit(Directive.MUL);
+    } else if (TokenState.token === TokenKind.Divide) {
+      next();
+      emit(Directive.PUSH);
+      expr(TokenKind.Multiply + 1);
+      emit(Directive.DIV);
+    } else if (TokenState.token === TokenKind.LessThan) {
+      next();
+      emit(Directive.PUSH);
+      expr(TokenKind.Add);
+      emit(Directive.LT);
+    } else if (TokenState.token === ";") {
+      next();
+    } else if (TokenState.token === TokenKind.Assign) {
+      next();
+      const target = VM.pop();
+      const load = VM.pop();
+      if (load !== Directive.LOAD || typeof target !== "string") {
+        error("PARSE", "bad lvalue in assignment");
+      }
+      expr(TokenKind.Assign);
+      emit(Directive.STORE, target);
+    } else {
+      error("PARSE", "parsing fail " + TokenState.token);
+    }
+  }
+}
+function parse() {
+  emit(Directive.JMP);
+  const mainTarget = VM.position();
+  emit(null);
+  let mainStart = null;
+  while (!Source.eof()) {
+    if (!TokenState.token)
+      next();
+    if (TokenState.token === TokenKind.Function) {
+      fnDecl();
+    } else {
+      if (mainStart === null)
+        mainStart = VM.position();
+      statement();
+    }
+  }
+  if (mainStart === null)
+    mainStart = VM.position();
+  VM.patch(mainTarget, mainStart);
+}
+
+// src/runtime/runtime.ts
+function resetRuntime(code) {
+  TokenState.reset();
+  Store.reset();
+  VM.reset();
+  Source.initialize(code);
+}
+
+// src/debug/inspect.ts
+function tokenLabel(token2) {
+  if (typeof token2 === "number")
+    return TokenKind.label(token2) ?? String(token2);
+  if (token2 === null)
+    return "EOF";
+  return token2;
+}
+function scanTokens(code) {
+  resetRuntime(code);
+  const tokens = [];
+  while (!Source.eof()) {
+    const state = next();
+    if (state.token !== null) {
+      tokens.push({
+        label: tokenLabel(state.token),
+        value: state.value,
+        line: state.startLine,
+        column: state.startColumn,
+        length: state.length
+      });
+    }
+  }
+  return tokens;
+}
+function inspect(code) {
+  const tokens = scanTokens(code);
+  resetRuntime(code);
+  parse();
+  const trace = VM.trace();
+  return {
+    directives: VM.directives(),
+    env: Object.fromEntries(Store.env),
+    result: Store.ax,
+    tokens,
+    trace
+  };
+}
+
+// src/index.ts
+function execute2(code) {
+  resetRuntime(code);
+  parse();
+  VM.execute();
+  return Store.ax;
+}
+export {
+  inspect,
+  execute2 as execute
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "langsagne",
+  "version": "0.1.0",
+  "description": "minimal programming language parser and execution experiment",
+  "type": "module",
+  "main": "./dist/index.js",
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "build": "rm -rf dist && bun build ./src/index.ts --outdir ./dist --target node --format esm",
+    "test": "bun test",
+    "exec": "bun scripts/exec.ts",
+    "web:build": "next build web",
+    "web:dev": "next dev web",
+    "web:start": "next start web",
+    "prepublishOnly": "bun run build"
+  },
+  "packageManager": "bun@1.3.13",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/huozhi/langsagne.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/huozhi/langsagne/issues"
+  },
+  "homepage": "https://github.com/huozhi/langsagne#readme",
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4.3.0",
+    "@types/bun": "^1.3.14",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "next": "^16.2.6",
+    "postcss": "^8.5.14",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
+    "tailwindcss": "^4.3.0",
+    "typescript": "^6.0.3"
+  }
+}