@openload28/tt-lang 1.0.0-dev.20260828.263

package/README.md

@@ -0,0 +1,106 @@
+# @openload28/tt-lang
+
+**tt** is a tiny preprocessor language that compiles to TypeScript. It adds
+Rust-style tagged unions and pattern matching, concise `Option`/`Result`
+control flow, pipelines, and mutation-safe bindings while keeping valid
+TypeScript valid.
+
+This package installs `ttc`, the tt compiler, as a prebuilt native binary —
+no Rust toolchain required.
+
+For a complete Bun + Vite project, or to add tt to an existing TypeScript
+project, use the initializer instead:
+
+```sh
+bunx @openload28/create-tt@next my-app
+bunx @openload28/create-tt@next init
+```
+
+`ttc` drives TypeScript 7 and takes it from your project's own
+`node_modules` — the same package your build uses, and the only place it
+looks. The TT installer does not add it for you:
+
+```sh
+bun add -d @openload28/tt-lang@next typescript@7.1.0-dev.20260826.1
+```
+
+Declaration output (`ttc --types`, editor `.tt.d.ts` sidecars) and content
+mappers (below) use APIs that arrived in TypeScript 7.1; everything else
+works on 7.0. See the
+[installation guide](https://github.com/load28/tt/blob/main/docs/getting-started.md).
+
+```sh
+bunx ttc -o build src/     # compile a source tree to TypeScript
+bunx ttc --check src/      # check without writing anything
+bunx ttc --types src/      # editor/typecheck declarations
+```
+
+On TypeScript 7.1+, `.ts` files can import `.tt` directly — this package
+is a TypeScript **content mapper**, so the compiler holds the transform
+virtually (no sidecar files). Declare it once in `tsconfig.json` and run
+`tsc` with `--runExternalCode`:
+
+```jsonc
+"contentMappers": [
+  { "package": "@openload28/tt-lang", "extensions": [".tt", ".ttx"] }
+]
+```
+
+Using a bundler? [`@openload28/unplugin-tt`](https://github.com/load28/tt/tree/main/integrations/unplugin)
+reads `.tt` files directly in Vite, Rollup, webpack, Rspack, esbuild and
+Farm, and finds this package's binary automatically.
+
+For editor support, download `tt-language-<version>.vsix` from the newest
+[GitHub Releases](https://github.com/load28/tt/releases) pre-release and use
+**Extensions: Install from VSIX...** in VS Code.
+
+## Supported platforms
+
+Prebuilt binaries ship as optional dependencies; npm installs the one
+matching your machine.
+
+| Package | OS | CPU |
+|---------|----|----|
+| `@openload28/tt-lang-linux-x64` | Linux | x64 (static musl build) |
+| `@openload28/tt-lang-linux-arm64` | Linux | arm64 (static musl build) |
+| `@openload28/tt-lang-darwin-x64` | macOS | x64 |
+| `@openload28/tt-lang-darwin-arm64` | macOS | arm64 |
+| `@openload28/tt-lang-win32-x64-msvc` | Windows | x64 (MSVC) |
+
+On other platforms, build from source
+(`cargo install --git https://github.com/load28/tt`) and set the
+`TTC_BINARY` environment variable to the resulting binary.
+
+## API
+
+The package exports one helper for tools that want to spawn the compiler
+directly:
+
+```js
+const { binaryPath } = require("@openload28/tt-lang");
+binaryPath(); // absolute path to the ttc binary for this platform
+```
+
+## Local development install
+
+In a checkout of the [tt repository](https://github.com/load28/tt),
+`./scripts/setup` stamps this directory for local installs. A project can
+then use the work-in-progress compiler like any other dependency:
+
+```sh
+pnpm add -D file:/path/to/tt/npm/tt-lang
+```
+
+The launcher runs the repository's `target/release/ttc`; TypeScript still
+comes from the consuming project, exactly as it does for a published
+install. Published installs are unaffected (the stamp file is not committed
+or published).
+
+## Documentation
+
+Language reference, CLI options, standard library and error index:
+<https://github.com/load28/tt#readme>.
+
+## License
+
+MIT

package/bin/ttc.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+/* --------------------------------------------------------------------------
+ * `ttc` launcher — thin veneer over the native binary from the platform
+ * package. All arguments, stdio and the exit code pass through untouched,
+ * so `npx ttc` behaves exactly like a natively installed ttc.
+ *
+ * In a local development install (`scripts/setup` in the TT repository,
+ * then `pnpm add -D file:.../npm/tt-lang`) the binary is the repository's
+ * release build instead (dev.js). Nothing else differs: TypeScript comes
+ * from the consuming project either way.
+ * ----------------------------------------------------------------------- */
+"use strict";
+
+const { spawnSync } = require("node:child_process");
+
+const { binaryPath } = require("../index.js");
+const { devEnvironment } = require("../dev.js");
+
+let binary;
+try {
+  // TTC_BINARY stays the strongest override, exactly as in binaryPath().
+  const dev = process.env.TTC_BINARY ? null : devEnvironment();
+  binary = dev ? dev.binary : binaryPath();
+} catch (error) {
+  console.error(error.message);
+  process.exit(1);
+}
+
+const result = spawnSync(binary, process.argv.slice(2), { stdio: "inherit" });
+if (result.error) {
+  console.error(`ttc: failed to run ${binary}: ${result.error.message}`);
+  process.exit(1);
+}
+if (result.signal) {
+  // Re-raise so the parent observes the same termination signal.
+  process.kill(process.pid, result.signal);
+}
+process.exit(result.status ?? 1);

package/dev.js

@@ -0,0 +1,63 @@
+/* --------------------------------------------------------------------------
+ * @openload28/tt-lang local development mode — created by `scripts/setup` in the TT
+ * repository, absent from published installs.
+ *
+ * `tt-dev.local.json` beside this file (written by setup, gitignored) marks
+ * the package as a local `file:` install and names the TT repository root,
+ * from which the one thing this layer supplies is derived:
+ *
+ *   ttc  <root>/target/release/ttc            (the release build)
+ *
+ * TypeScript is *not* part of it: ttc resolves TypeScript 7 from the
+ * consuming project's own `node_modules`, and there is no second way to
+ * name one (`src/typescript/toolchain.rs`). A development install differs
+ * from a published one in which ttc runs, and in nothing else.
+ *
+ * This whole layer is temporary (docs/tasks/TASK-090): once TT ships a
+ * verified TypeScript inside its own package, delete this module together
+ * with scripts/setup and .tt-dev/.
+ * ----------------------------------------------------------------------- */
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const DEV_CONFIG = path.join(__dirname, "tt-dev.local.json");
+
+/** The parsed JSON object of `file`, or null when missing/unreadable. */
+function readConfig(file) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The local development environment `scripts/setup` configured, or null when
+ * this is a regular published install (no `tt-dev.local.json`).
+ *
+ * Throws when the config exists but the binary it names is gone — running
+ * some other ttc silently would be worse than failing with the fix.
+ *
+ * @returns {{ binary: string } | null}
+ */
+function devEnvironment() {
+  const config = readConfig(DEV_CONFIG);
+  const root = config && typeof config.root === "string" ? config.root : null;
+  if (root === null) return null;
+
+  const exe = process.platform === "win32" ? "ttc.exe" : "ttc";
+  const binary = path.join(root, "target", "release", exe);
+  if (!fs.existsSync(binary)) {
+    throw new Error(
+      `@openload28/tt-lang: this is a local development install (${DEV_CONFIG}), ` +
+        `but ${binary} does not exist. Run ./scripts/setup in ${root}, ` +
+        `then reinstall this package.`,
+    );
+  }
+  return { binary };
+}
+
+module.exports = { devEnvironment };

package/index.js

@@ -0,0 +1,64 @@
+/* --------------------------------------------------------------------------
+ * @openload28/tt-lang — locate the platform-specific ttc binary.
+ *
+ * The actual compiler ships in per-platform packages (@openload28/tt-lang-linux-x64,
+ * @openload28/tt-lang-darwin-arm64, ...) wired up as optionalDependencies: npm installs
+ * only the one matching the host. This module finds that binary so tools
+ * (the `ttc` bin launcher, @openload28/unplugin-tt, editor servers) can spawn it
+ * directly without paying for an extra node process per call.
+ * ----------------------------------------------------------------------- */
+"use strict";
+
+const path = require("node:path");
+const PLATFORMS = require("./platforms.json");
+
+/** Platforms a prebuilt ttc binary is published for. */
+const SUPPORTED = Object.keys(PLATFORMS);
+
+/** `"linux-x64"`-style key for the current process, supported or not. */
+function platformKey() {
+  return `${process.platform}-${process.arch}`;
+}
+
+/** npm package containing the binary for a platform key. */
+function platformPackageName(key) {
+  return PLATFORMS[key]?.package;
+}
+
+/**
+ * Absolute path to the ttc binary for this platform.
+ *
+ * Resolution order: the `TTC_BINARY` environment variable (escape hatch for
+ * local builds and tests), then a local development install (`scripts/setup`
+ * in the TT repository — see dev.js), then the installed platform package.
+ * Throws with install guidance when none is available.
+ *
+ * @returns {string}
+ */
+function binaryPath() {
+  const override = process.env.TTC_BINARY;
+  if (override) return path.resolve(override);
+
+  const dev = require("./dev.js").devEnvironment();
+  if (dev) return dev.binary;
+
+  const key = platformKey();
+  const exe = process.platform === "win32" ? "ttc.exe" : "ttc";
+  const pkg = platformPackageName(key);
+  try {
+    return require.resolve(`${pkg}/bin/${exe}`);
+  } catch {
+    const reason = pkg
+      ? `the ${pkg} package is not installed — it is an optionalDependency of @openload28/tt-lang, ` +
+        `so this usually means optional dependencies were disabled (--no-optional / ` +
+        `--omit=optional) or the lockfile was created on a different platform. ` +
+        `Reinstalling @openload28/tt-lang should fix it.`
+      : `no prebuilt ttc binary is published for ${key}. Prebuilt platforms: ` +
+        `${SUPPORTED.join(", ")}. You can build from source with ` +
+        `"cargo install --git https://github.com/load28/tt" and point the ` +
+        `TTC_BINARY environment variable at the resulting binary.`;
+    throw new Error(`@openload28/tt-lang: cannot find the ttc binary: ${reason}`);
+  }
+}
+
+module.exports = { binaryPath, platformKey, platformPackageName };

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@openload28/tt-lang",
+  "version": "1.0.0-dev.20260828.263",
+  "description": "tt — a tiny TypeScript preprocessor adding Rust-style variants, match expressions, try, let-else, if let and the pipeline operator. Installs the ttc compiler.",
+  "license": "MIT",
+  "bin": {
+    "ttc": "bin/ttc.js"
+  },
+  "main": "index.js",
+  "typescript": {
+    "contentMapper": {
+      "exec": [
+        "node",
+        "bin/ttc.js",
+        "--content-mapper"
+      ]
+    }
+  },
+  "files": [
+    "bin/ttc.js",
+    "index.js",
+    "platforms.json",
+    "dev.js",
+    "tt-dev.local.json",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/load28/tt",
+    "directory": "npm/tt-lang"
+  },
+  "homepage": "https://github.com/load28/tt#readme",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "keywords": [
+    "typescript",
+    "compiler",
+    "preprocessor",
+    "tagged-union",
+    "pattern-matching",
+    "match",
+    "tt"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "optionalDependencies": {
+    "@openload28/tt-lang-linux-x64": "1.0.0-dev.20260828.263",
+    "@openload28/tt-lang-linux-arm64": "1.0.0-dev.20260828.263",
+    "@openload28/tt-lang-darwin-x64": "1.0.0-dev.20260828.263",
+    "@openload28/tt-lang-darwin-arm64": "1.0.0-dev.20260828.263",
+    "@openload28/tt-lang-win32-x64-msvc": "1.0.0-dev.20260828.263"
+  }
+}

package/platforms.json

@@ -0,0 +1,27 @@
+{
+  "linux-x64": {
+    "package": "@openload28/tt-lang-linux-x64",
+    "os": "linux",
+    "cpu": "x64"
+  },
+  "linux-arm64": {
+    "package": "@openload28/tt-lang-linux-arm64",
+    "os": "linux",
+    "cpu": "arm64"
+  },
+  "darwin-x64": {
+    "package": "@openload28/tt-lang-darwin-x64",
+    "os": "darwin",
+    "cpu": "x64"
+  },
+  "darwin-arm64": {
+    "package": "@openload28/tt-lang-darwin-arm64",
+    "os": "darwin",
+    "cpu": "arm64"
+  },
+  "win32-x64": {
+    "package": "@openload28/tt-lang-win32-x64-msvc",
+    "os": "win32",
+    "cpu": "x64"
+  }
+}