@algosail/lang 0.2.11 → 0.5.0

package/test/typecheck/stack-check-stage7.test.js

@@ -0,0 +1,160 @@
+/**
+ * L3 этап 7: эффекты +Async / +Fail, всплытие (RFC-0.1 §5.7, RFC-typecheck §5.6–5.7).
+ */
+import test from 'brittle'
+import path from 'node:path'
+import { typecheckSail } from '../../index.js'
+
+const root = path.resolve('/virtual/sail-l3-st7')
+function vfs (files) {
+  const norm = Object.fromEntries(
+    Object.entries(files).map(([k, v]) => [path.normalize(k), v])
+  )
+  return (p) => norm[path.normalize(p)] ?? null
+}
+
+test('L3 stage7: +Async вызывает +Async — ок', function (t) {
+  const main = path.join(root, 'async-ok.sail')
+  const src = [
+    '@asyncCallee ( -> +Async )',
+    '',
+    '@caller ( -> +Async )',
+    '  /asyncCallee',
+    ''
+  ].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+  const fx = r.env?.definitionEffectsByPath?.get(main)?.get('caller')
+  t.ok(fx?.asyncDefinition === true)
+  t.end()
+})
+
+test('L3 stage7: обёртка с исходящим -Async вызывает +Async — ок', function (t) {
+  const main = path.join(root, 'async-wrap.sail')
+  const src = [
+    '@asyncCallee ( -> +Async )',
+    '',
+    '@wrap ( -> -Async )',
+    '  /asyncCallee',
+    ''
+  ].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+  t.end()
+})
+
+test('L3 stage7: обёртка с исходящим -Fail вызывает +Fail — ок', function (t) {
+  const main = path.join(root, 'fail-wrap.sail')
+  const src = [
+    '@risky ( -> +Fail )',
+    '',
+    '@wrap ( -> -Fail )',
+    '  /risky',
+    ''
+  ].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+  t.end()
+})
+
+test('L3 stage7: синхронное слово вызывает +Async — E1310', function (t) {
+  const main = path.join(root, 'e1310.sail')
+  const src = [
+    '@asyncCallee ( -> +Async )',
+    '',
+    '@sync ( -> )',
+    '  /asyncCallee',
+    ''
+  ].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok === false)
+  t.ok(r.diagnostics.some((d) => d.code === 'E1310'), r.diagnostics.map((d) => d.code).join(','))
+  t.end()
+})
+
+test('L3 stage7: вызов +Fail без +Fail у вызывающего — E1312', function (t) {
+  const main = path.join(root, 'e1312.sail')
+  const src = [
+    '@mayFail ( -> +Fail )',
+    '',
+    '@sync ( -> )',
+    '  /mayFail',
+    ''
+  ].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok === false)
+  t.ok(r.diagnostics.some((d) => d.code === 'E1312'), r.diagnostics.map((d) => d.code).join(','))
+  t.end()
+})
+
+test('L3 stage7: quotation + call всплывает +Async — без +Async у слова E1310', function (t) {
+  const main = path.join(root, 'q-call-async-bad.sail')
+  const src = [
+    '@asyncCallee ( -> +Async )',
+    '',
+    '@bad ( -> )',
+    '  ( /asyncCallee )',
+    '  call',
+    ''
+  ].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok === false)
+  t.ok(r.diagnostics.some((d) => d.code === 'E1310'), r.diagnostics.map((d) => d.code).join(','))
+  t.end()
+})
+
+test('L3 stage7: quotation + call с +Async у внешнего слова — ок', function (t) {
+  const main = path.join(root, 'q-call-async-good.sail')
+  const src = [
+    '@asyncCallee ( -> +Async )',
+    '',
+    '@good ( -> +Async )',
+    '  ( /asyncCallee )',
+    '  call',
+    ''
+  ].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+  t.end()
+})
+
+test('L3 stage7: callSiteEffectMarks — calleeAsync на вызове', function (t) {
+  const main = path.join(root, 'marks.sail')
+  const src = [
+    '@asyncCallee ( -> +Async )',
+    '',
+    '@caller ( -> +Async )',
+    '  /asyncCallee',
+    ''
+  ].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok)
+  const marks = r.env?.callSiteEffectMarks ?? []
+  const ref = marks.find(
+    (m) => m.kind === 'word_ref' && m.name === 'asyncCallee'
+  )
+  t.ok(ref?.calleeAsync === true)
+  t.ok(ref?.callerWord === 'caller')
+  t.end()
+})
+
+test('L3 stage7: callSiteEffectMarks — под -Async calleeAsync не ставится (вариант B)', function (t) {
+  const main = path.join(root, 'marks-wrap-async.sail')
+  const src = [
+    '@asyncCallee ( -> +Async )',
+    '',
+    '@wrap ( -> -Async )',
+    '  /asyncCallee',
+    ''
+  ].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok)
+  const marks = r.env?.callSiteEffectMarks ?? []
+  const ref = marks.find(
+    (m) => m.kind === 'word_ref' && m.name === 'asyncCallee'
+  )
+  t.ok(ref)
+  t.is(ref.calleeAsync, false)
+  t.is(ref.callerWord, 'wrap')
+  t.end()
+})

package/test/typecheck/stack-check-stage8.test.js

@@ -0,0 +1,146 @@
+/**
+ * L3 этап 8: автоген ADT и eliminator-ы (RFC-0.1 §7, RFC-typecheck §5.8).
+ */
+import test from 'brittle'
+import path from 'node:path'
+import { typecheckSail } from '../../index.js'
+
+const root = path.resolve('/virtual/sail-l3-st8')
+function vfs (files) {
+  const norm = Object.fromEntries(
+    Object.entries(files).map(([k, v]) => [path.normalize(k), v])
+  )
+  return (p) => norm[path.normalize(p)] ?? null
+}
+
+test('L3 stage8: sum /nothing — ( -> (Maybe a) )', function (t) {
+  const main = path.join(root, 'sum-nothing.sail')
+  const src = [
+    '&Maybe a',
+    '| Nothing',
+    '| Just a',
+    '',
+    '@w ( -> (Maybe a) )',
+    '  /nothing',
+    ''
+  ].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+  t.end()
+})
+
+test('L3 stage8: sum /just — ( a -> (Maybe a) )', function (t) {
+  const main = path.join(root, 'sum-just.sail')
+  const src = [
+    '&Maybe a',
+    '| Nothing',
+    '| Just a',
+    '',
+    '@w ( Num -> (Maybe a) )',
+    '  /just',
+    ''
+  ].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+  t.end()
+})
+
+test('L3 stage8: eliminator /maybe — согласованные ветки', function (t) {
+  const main = path.join(root, 'sum-maybe-ok.sail')
+  const src = [
+    '&Maybe a',
+    '| Nothing',
+    '| Just a',
+    '',
+    '@nothingQuot ( -> q:( ~s -> ~s ) )',
+    '  ( )',
+    '',
+    '@justQuot ( -> q:( ~s a -> ~s ) )',
+    '  ( drop )',
+    '',
+    '@w ( ~s (Maybe a) -> ~s )',
+    '  /nothingQuot',
+    '  /justQuot',
+    '  /maybe',
+    ''
+  ].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+  t.end()
+})
+
+test('L3 stage8: eliminator — не хватает quotation — E1308', function (t) {
+  const main = path.join(root, 'sum-maybe-e1308.sail')
+  const src = [
+    '&Maybe a',
+    '| Nothing',
+    '| Just a',
+    '',
+    '@w ( ~s (Maybe a) -> ~s )',
+    '  /maybe',
+    ''
+  ].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok === false)
+  const codes = r.diagnostics.map((d) => d.code)
+  t.ok(codes.includes('E1308'), codes.join(','))
+  t.end()
+})
+
+test('L3 stage8: eliminator — несовместимые ветки — E1307', function (t) {
+  const main = path.join(root, 'sum-maybe-e1307.sail')
+  const src = [
+    '&Maybe a',
+    '| Nothing',
+    '| Just a',
+    '',
+    '@w ( ~s (Maybe a) -> ~s Num )',
+    '  ( )',
+    '  ( )',
+    '  /maybe',
+    ''
+  ].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok === false)
+  t.ok(r.diagnostics.some((d) => d.code === 'E1307'), r.diagnostics.map((d) => d.code).join(','))
+  t.end()
+})
+
+test('L3 stage8: product /point и /withPoint', function (t) {
+  const main = path.join(root, 'prod-point.sail')
+  const src = [
+    '&Point',
+    ':x Num',
+    ':y Num',
+    '',
+    '@q ( -> q:( ~s Num Num -> ~s ) )',
+    '  ( nip drop )',
+    '',
+    '@w ( Point -> )',
+    '  /q',
+    '  /withPoint',
+    '',
+    '@t ( -> Point )',
+    '  1 2 /point',
+    ''
+  ].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+  t.end()
+})
+
+test('L3 stage8: product геттер /xPoint', function (t) {
+  const main = path.join(root, 'prod-getter.sail')
+  const src = [
+    '&Point',
+    ':x Num',
+    ':y Num',
+    '',
+    '@w ( Point -> Num )',
+    '  /xPoint',
+    ''
+  ].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+  t.end()
+})

package/test/typecheck/stack-check-stage9.test.js

@@ -0,0 +1,105 @@
+/**
+ * L3 этап 9: снимки стека для lowering (RFC-IR-0.1 §3, RFC-typecheck-0.1 §3, §6).
+ */
+import test from 'brittle'
+import path from 'node:path'
+import { typecheckSail } from '../../index.js'
+import { verifySnapshotChainStitches } from '../../lib/typecheck/stack-step-snapshots.js'
+
+const root = path.resolve('/virtual/sail-l3-st9')
+function vfs (files) {
+  const norm = Object.fromEntries(
+    Object.entries(files).map(([k, v]) => [path.normalize(k), v])
+  )
+  return (p) => norm[path.normalize(p)] ?? null
+}
+
+test('L3 stage9: цепочка pre/post для литерал + dup', function (t) {
+  const main = path.join(root, 'snap-dup.sail')
+  const src = ['@w ( -> Num Num )', '', '  1', '', '  dup', ''].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+  const rec = r.env.stackSnapshotsByPath.get(main).get('w')
+  t.is(rec.steps.length, 2)
+  t.ok(verifySnapshotChainStitches(rec))
+  t.is(rec.steps[0].pre.length, 0)
+  t.is(rec.steps[0].post.length, 1)
+  t.is(rec.steps[0].post[0].kind, 'prim')
+  t.is(rec.steps[0].post[0].name, 'Num')
+  t.is(rec.steps[1].pre.length, 1)
+  t.is(rec.steps[1].post.length, 2)
+  t.end()
+})
+
+test('L3 stage9: вложенная quotation — nestedByParentStep', function (t) {
+  const main = path.join(root, 'snap-nested.sail')
+  const src = ['@w ( -> ( -> Num ) )', '', '  ( 1 )', ''].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+  const rec = r.env.stackSnapshotsByPath.get(main).get('w')
+  t.is(rec.steps.length, 1)
+  const nested = rec.nestedByParentStep.get(0)
+  t.ok(nested)
+  t.is(nested.steps.length, 1)
+  t.ok(verifySnapshotChainStitches(rec))
+  t.ok(verifySnapshotChainStitches(nested))
+  t.end()
+})
+
+test('L3 stage9: полиморфный вызов — снимок с Num', function (t) {
+  const main = path.join(root, 'snap-poly.sail')
+  const src = [
+    '@id ( a -> a )',
+    '',
+    '@w ( Num -> Num )',
+    '',
+    '  /id',
+    ''
+  ].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+  const rec = r.env.stackSnapshotsByPath.get(main).get('w')
+  t.is(rec.steps.length, 1)
+  t.is(rec.steps[0].pre[0].kind, 'prim')
+  t.is(rec.steps[0].pre[0].name, 'Num')
+  t.is(rec.steps[0].post[0].kind, 'prim')
+  t.is(rec.steps[0].post[0].name, 'Num')
+  t.end()
+})
+
+test('L3 stage9: при ошибке тела — частичный снимок (pre на шаге сбоя) и второе слово проверяется', function (t) {
+  const main = path.join(root, 'snap-fail.sail')
+  const src = [
+    '@bad ( -> )',
+    '',
+    '  drop',
+    '',
+    '@ok ( -> )',
+    '',
+    ''
+  ].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok === false)
+  const per = r.env.stackSnapshotsByPath.get(main)
+  t.ok(per)
+  const badRec = per.get('bad')
+  t.ok(badRec, 'RFC-typecheck §3: снимок для слова с ошибкой в теле')
+  t.ok(badRec.steps[0].pre)
+  t.ok(badRec.steps[0].post === undefined, 'post на ошибочном шаге не обязателен')
+  t.ok(per.has('ok'))
+  t.is(per.get('ok').steps.length, 0)
+  t.end()
+})
+
+test('L3 stage9: post[last] согласуется с объявленным выходом слова', function (t) {
+  const main = path.join(root, 'snap-out.sail')
+  const src = ['@w ( -> Num Num )', '', '  1', '', '  dup', ''].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok)
+  const rec = r.env.stackSnapshotsByPath.get(main).get('w')
+  const lastPost = rec.steps[rec.steps.length - 1].post
+  t.is(lastPost.length, 2)
+  t.is(lastPost[0].name, 'Num')
+  t.is(lastPost[1].name, 'Num')
+  t.end()
+})

package/test/typecheck/typecheck-env.test.js

@@ -0,0 +1,53 @@
+/**
+ * L3 этап 1: окружение typecheck — wordDeclByPath, scopeByPath, топо-порядок модулей.
+ */
+import test from 'brittle'
+import path from 'node:path'
+import { typecheckSail } from '../../index.js'
+import { resolveExportedWord } from '../../lib/typecheck/build-type-env.js'
+
+const root = path.resolve('/virtual/sail-l3-env')
+function vfs (files) {
+  const norm = Object.fromEntries(
+    Object.entries(files).map(([k, v]) => [path.normalize(k), v])
+  )
+  return (p) => norm[path.normalize(p)] ?? null
+}
+
+test('typecheck env: один модуль — слова и scope.unq', function (t) {
+  const main = path.join(root, 'main.sail')
+  const src = ['@noop ( -> )', '', '@main ( -> )', '', '  /noop'].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok)
+  const env = r.env
+  t.ok(env, 'env')
+  const words = env.wordDeclByPath.get(main)
+  t.ok(words?.get('main')?.signature, 'main signature')
+  t.ok(Array.isArray(words?.get('main')?.body), 'main body')
+  t.ok(words?.get('noop')?.signature, 'noop signature')
+  const sc = env.scopeByPath.get(main)
+  t.ok(sc?.unq?.has('main') && sc.unq.has('noop'), 'unq')
+  t.end()
+})
+
+test('typecheck env: два модуля — dep раньше entry в modulePathsOrdered, importMap', function (t) {
+  const main = path.join(root, 'main.sail')
+  const lib = path.join(root, 'lib.sail')
+  const files = {
+    [main]: ['+Lib ./lib.sail', '@main ( -> )', '', '  ~Lib/hello'].join('\n'),
+    [lib]: ['@hello ( -> )', '', ''].join('\n')
+  }
+  const r = typecheckSail({ entryPath: main, readFile: vfs(files) })
+  t.ok(r.ok, r.diagnostics.map((d) => d.code + ' ' + d.message).join('; '))
+  const env = r.env
+  const order = env.modulePathsOrdered
+  const iLib = order.indexOf(lib)
+  const iMain = order.indexOf(main)
+  t.ok(iLib >= 0 && iMain >= 0)
+  t.ok(iLib < iMain, 'lib before main in topo order')
+  const dep = env.scopeByPath.get(main).importMap.get('Lib')
+  t.ok(dep && dep.path === lib, 'importMap Lib -> lib snapshot')
+  const w = resolveExportedWord(dep, 'hello')
+  t.ok(w && w.name === 'hello', 'resolveExportedWord')
+  t.end()
+})

package/test/typecheck/typecheck-pipeline.test.js

@@ -0,0 +1,37 @@
+/**
+ * L3 этап 0: вход после L2, проброс диагностик при падении имён, заглушка при успехе.
+ */
+import test from 'brittle'
+import path from 'node:path'
+import { typecheckSail } from '../../index.js'
+
+const root = path.resolve('/virtual/sail-l3')
+function vfs (files) {
+  const norm = Object.fromEntries(
+    Object.entries(files).map(([k, v]) => [path.normalize(k), v])
+  )
+  return (p) => norm[path.normalize(p)] ?? null
+}
+
+test('typecheckSail: при ошибке L2 те же diagnostics, без snapshots', function (t) {
+  const main = path.join(root, 'main.sail')
+  const src = '@main ( -> )\n\n  /nope\n'
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok === false)
+  t.ok(!('snapshots' in r) || r.snapshots === undefined)
+  const d = r.diagnostics.find((x) => x.code === 'E1201')
+  t.ok(d, 'E1201')
+  t.end()
+})
+
+test('typecheckSail: при успехе L2 ok и пустые diagnostics L3, есть snapshots', function (t) {
+  const main = path.join(root, 'main.sail')
+  const src = ['@noop ( -> )', '', '@main ( -> )', '', '  /noop'].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok, r.diagnostics.map((d) => d.code + ' ' + d.message).join('; '))
+  t.is(r.diagnostics.length, 0)
+  t.ok(r.snapshots instanceof Map)
+  t.ok(r.snapshots.has(main))
+  t.ok(r.env && r.env.wordDeclByPath?.get(main)?.has('main'), 'env этап 1')
+  t.end()
+})

package/README.md

@@ -1,37 +0,0 @@
-# @algosail/lang
-
-Sail language tooling. Re-exports parser and typecheck.
-
-## CLI
-
-```bash
-sail check <file.sail>           # Typecheck
-sail compile <file.sail> [options]  # Compile to JS
-```
-
-Options for `compile`: `--out <file.js>`, `--no-source-map`, `-` (stdout).
-
-## Exports
-
-```javascript
-import { createParser, typecheck } from '@algosail/lang'
-```
-
-## Docs
-
-- [FFI-GUIDE.md](docs/FFI-GUIDE.md) — JSDoc format for FFI modules
-- [ARCHITECTURE.md](docs/ARCHITECTURE.md) — Pipeline, packages, dependencies
-- [TESTING.md](docs/TESTING.md) — Brittle setup, integration tests
-- [CHANGELOG.md](docs/CHANGELOG.md) — Version history
-- [RELEASE.md](docs/RELEASE.md) — Release checklist
-
-## Packages
-
-| Package | Description |
-|---------|-------------|
-| @algosail/parser | Parse Sail + JS → symbol table |
-| @algosail/typecheck | Type checking |
-| @algosail/compiler | Sail → JS (CLI: `sail-compile`) |
-| @algosail/builtins | Builtin words |
-| @algosail/tree-sitter | Grammar |
-| @algosail/lsp | LSP server (hover, completion, go-to-definition) |

package/cli/sail.js

@@ -1,151 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Sail CLI — sail check | sail compile
- */
-
-const args = process.argv.slice(2)
-const cmd = args[0]
-
-if (!cmd || cmd === '-h' || cmd === '--help') {
-  console.log(`sail - Sail language tooling
-
-Usage:
-  sail check <file.sail>       Typecheck a Sail file
-  sail compile <file.sail>     Compile Sail to JavaScript
-
-Options for compile:
-  --out <file.js>              Output path (default: input.js)
-  --no-source-map              Disable source map generation
-  -                           Write to stdout
-
-Examples:
-  sail check main.sail
-  sail compile main.sail --out dist/main.js
-  sail compile main.sail -
-`)
-  process.exit(cmd === '-h' || cmd === '--help' ? 0 : 1)
-}
-
-const rest = args.slice(1)
-
-if (cmd === 'check') {
-  await runCheck(rest)
-} else if (cmd === 'compile') {
-  await runCompile(rest)
-} else {
-  console.error(`sail: unknown command '${cmd}'. Use 'sail check' or 'sail compile'.`)
-  process.exit(1)
-}
-
-async function runCheck(args) {
-  const filePath = args.find((a) => !a.startsWith('-'))
-  if (!filePath) {
-    console.error('Usage: sail check <path-to-file.sail>')
-    process.exit(1)
-  }
-
-  const { createParser } = await import('@algosail/parser')
-  const { typecheck } = await import('@algosail/typecheck')
-  const { readFile } = await import('node:fs/promises')
-  const { pathToFileURL } = await import('node:url')
-  const { resolve } = await import('node:path')
-  const { formatError } = await import('@algosail/compiler/lib/formatError.js')
-  const { addErrorHints } = await import('@algosail/compiler/lib/errorHints.js')
-
-  const absPath = resolve(process.cwd(), filePath)
-  const uri = pathToFileURL(absPath).href
-
-  let text
-  try {
-    text = await readFile(absPath, 'utf8')
-  } catch (err) {
-    console.error(`sail check: cannot read ${filePath}: ${err.message}`)
-    process.exit(1)
-  }
-
-  const parser = await createParser()
-  const result = await parser.parseSail(uri, text)
-  const parseErrors = (result.errors ?? []).map((e) => ({
-    message: e.type === 'error' ? `Parse error: ${e.text}` : `Parse error: missing ${e.text}`,
-    startPosition: e.startPosition,
-    uri,
-  }))
-  const typeErrors = typecheck(result).map((e) => {
-    const hint = addErrorHints(e)
-    return { ...e, uri, ...(hint && { hint }) }
-  })
-  const errors = [...parseErrors, ...typeErrors]
-
-  if (errors.length > 0) {
-    for (const err of errors) {
-      console.error(formatError({ ...err, uri }, uri))
-    }
-    process.exit(1)
-  }
-}
-
-async function runCompile(args) {
-  let inputPath = null
-  let outPath = null
-
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--out' && args[i + 1]) {
-      outPath = args[i + 1]
-      i++
-    } else if (!args[i].startsWith('-')) {
-      inputPath = args[i]
-    }
-  }
-
-  if (!inputPath) {
-    console.error('Usage: sail compile <input.sail> [--out <output.js>] [--no-source-map]')
-    process.exit(1)
-  }
-
-  const { compile } = await import('@algosail/compiler')
-  const { formatError } = await import('@algosail/compiler/lib/formatError.js')
-  const { readFile, writeFile } = await import('node:fs/promises')
-  const { dirname, resolve, basename } = await import('node:path')
-  const { pathToFileURL } = await import('node:url')
-
-  const absPath = resolve(process.cwd(), inputPath)
-  const uri = pathToFileURL(absPath).href
-
-  let source
-  try {
-    source = await readFile(absPath, 'utf8')
-  } catch (err) {
-    console.error(`sail compile: cannot read ${inputPath}: ${err.message}`)
-    process.exit(1)
-  }
-
-  const outputPath = outPath ?? inputPath.replace(/\.sail$/, '.js')
-  const compileOpts = {
-    outPath: outputPath !== '-' ? dirname(resolve(process.cwd(), outputPath)) : dirname(absPath),
-    sourceMap: outputPath !== '-' && !args.includes('--no-source-map'),
-    outFile: outputPath !== '-' ? resolve(process.cwd(), outputPath) : null,
-  }
-
-  const result = await compile(uri, source, compileOpts)
-
-  if (result.errors.length > 0) {
-    for (const err of result.errors) {
-      console.error(formatError({ ...err, uri }, uri))
-    }
-    process.exit(1)
-  }
-
-  if (outputPath === '-') {
-    process.stdout.write(result.js)
-  } else {
-    let js = result.js
-    if (result.sourceMap) {
-      const mapPath = outputPath + '.map'
-      await writeFile(mapPath, result.sourceMap, 'utf8')
-      js += `\n//# sourceMappingURL=${basename(mapPath)}`
-    }
-    await writeFile(outputPath, js, 'utf8')
-    console.log(`Compiled to ${outputPath}`)
-  }
-}