All of the corpus.
None of the supply chain.

The compiler stopped needing the ecosystem it serves

For a decade, “TypeScript without npm” was a contradiction in terms — the compiler itself was a Node program. To typecheck a single file you installed the runtime, the package manager, and the resolution algorithm of the very ecosystem you might have wanted to escape. TypeScript 7 ended that: the compiler is now native Go — ten times faster, and, the part that matters here, embeddable. A library you link, pin, and vendor. The moment the toolchain stopped requiring the ecosystem, keeping the ecosystem became a choice.

And the ecosystem is the worst liability in software. The registry is the most attacked supply chain in the industry, and the newest attack is aimed at machines: models hallucinate plausible package names, attackers register them, and the install succeeds. The frameworks churn on a two-year treadmill. The runtimes are companies — one foundation-run, two venture-funded. And an entire mitigation industry — SBOM scanners, dependency firewalls, lockfile auditors — exists to sell back the safety the architecture gave away.

Meanwhile the language carries the single most valuable asset in the agent era: the largest training corpus of any programming language. Every frontier model writes TypeScript better than it writes anything else. The corpus and the ecosystem were never the same thing. Streng is the split, executed: keep the language every model speaks; delete the world it learned to depend on.

Sell the absence, not the access

Every TypeScript framework since 2012 has made the same pitch: access — to two million packages, to the component ecosystem, to whatever npm has. Streng inverts the pitch entirely. The product is what cannot happen:

Five layers, one binary, one database

Each layer is a small framework kernel with a Dutch name and a familiar ancestor. All of them ship inside the streng binary; streng build links your app, the stdlib, and the engine into one executable.

A closed world owes you the batteries

In an open ecosystem, a missing battery is an npm install away. In a closed world, a missing battery is a wall. Deleting the registry therefore creates an obligation the registry never had: std/ must cover the entire B2B envelope, or the closed world is a cell instead of an estate. That obligation is the product — “batteries included” is a treadmill claim in an open world; in a closed one it is the definition of usable.

The gate teaches the corpus its manners

A model's first draft arrives with the ecosystem's reflexes — a lodash import, a zod schema, an as any to make the red squiggle stop. The gate answers in milliseconds, with the fix in the error. This conversation is the adoption path, and it converges because the loop is fast:

import isEqual from "lodash-es";
import { z } from "zod";

const input = z.object({ amount: z.number() })
              .parse(body);

const total = rows.reduce(sum) as any;

// three reflexes from the old world —
// each one learned from the corpus,
// each one a liability here

deal.ts:1 — "lodash-es" is not in the world.
  std/iter has deepEqual.
  fix: import { deepEqual } from "std/iter"

deal.ts:2 — validators are derived, not imported.
  Deal already knows its shape.
  fix: Deal.parse(body)

deal.ts:7 — `as any` never admits.
  total is Money when rows is Line[].
  fix: annotate rows: Line[]

The canonical artifact is the resource — plain TypeScript, no new syntax, and the type system is strong enough that the derived surface is exactly typed. In TypeScript, types are opinions that erase at runtime. In streng they are laws: every boundary type compiles to a validator, derived from the declaration, never imported from a vendor.

import { resource, states, money, pii, contact, belongsTo, by, orgScoped, role } from "std/erf";

export const Deal = resource("deal", {
  stage:   states("draft", "won", "lost"),  // history: every version
  amount:  money(),
  owner:   pii(contact()),                     // vault-routed · masked by default
  company: belongsTo("company"),
}, {
  horizon: by("assignment"),                  // who syncs / sees this row
  policy:  orgScoped.and(role("sales")),
});

// typeof Deal.Row is exact — the compiler is the first verifier.
// Deal.parse is the derived validator — types don't erase, they enforce.
// schema, migration, history, forms, REST + OpenAPI: derived, catalogued.

export const followUp = workflow(async (wf, dealId: DealId) => {
  await wf.step(sendIntro(dealId));
  await wf.sleep(days(3));                   // a row — survives deploys
  const ok = await wf.receive(Approval);     // waits for a human, or an agent
  if (ok) await wf.step(sendContract(dealId));
});

const verdict = await kooi.run(tenantHook, {
  capabilities: ["crm.read"],   // anything else is unnameable in the environment
  fuel: 1_000_000,              // exact step + allocation budget
});

$ streng check     # tsgo 7, vendored — the full graph, warm, in double-digit ms
$ streng test      # the runner ships in the binary
$ streng build     # ./crm — engine + stdlib + your app, one file
$ ./crm postgres://…   # there is nothing to install, anywhere in this transcript

What Streng refuses to have

Every exclusion is load-bearing. Most remove a vendor; the rest remove a way for the corpus's bad habits to become your incident.

Frozen between versions. Atomic across them.

Streng is not frozen at TypeScript 7 forever — it is frozen between epochs. When a new TypeScript's idioms have earned their place in the corpus, streng ships a new epoch: dialect, engine, stdlib, component library, workflow engine, and gate, upgraded together, as one artifact. “One version of everything” cuts both ways — nothing drifts between upgrades, and an upgrade is everything at once.

Because there is exactly one version of everything, migration is a property of the gate, not a research project. There is no dependency matrix, no peer solver, no “which combination of package versions works together” — the combination space has two points: the epoch you are on, and the one you are moving to. The gate re-checks the entire application against the new world and reports every incompatibility at once, fix in the error. Hours of listed, mechanical fixes instead of weeks of archaeology.

$ streng migrate 8            # dialect + engine + stdlib + gate move together
checking app/ against epoch 8 … 41 files · 214 ms
12 incompatibilities · every one listed · fixes in the errors

$ streng migrate 8 --commit   # one world, one step — the app and the framework land together
epoch 8 · 0 errors · nothing else in the company noticed

And an epoch is an offer, not an eviction. The old binary is complete and eternal — staying on epoch 7 is a supported posture, not abandonment, because a closed world has no transitive dependency quietly dropping support underneath you. The discipline is Go's compatibility promise applied to an entire framework — and it is precisely the discipline the open ecosystem cannot have, because nobody owns the whole world at once. Streng does. That is the point.

The best agent language was trained, not designed

Taal's premise was that you must invent a language to get a canonical corpus and a fast verifier. TypeScript 7 broke the premise: the largest corpus in existence now has the fastest typechecker ever shipped for it. Streng doesn't build the agent language — it fences the one the agents already have.

The endgame: agents write the language they know best, against a stdlib that is the whole world, gated by a checker that answers in the time a keystroke takes — and the classic failure modes of machine-written code (invented packages, unsound casts, drifting validators) are not reviewed away but unrepresentable.

The honest edges

The pitch, in one sentence: your language is the one every model already speaks; your entire dependency graph is one binary and one Postgres you can point at; and nothing in your product can import what you didn't ship.