ranger-compiler 3.4.0 → 3.5.1

package/CHANGELOG.md

@@ -7,26 +7,102 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [3.4.0] - 2026-09-16
-
-The last package on npm was **3.2.0**. 3.2.1, 3.3.0 and 3.3.1 were
-already dated in this file and never published there, so this tarball
-is the first that carries them.
-
-On the compiler: generic classes (`class History @params(Op)`),
-expanded into ordinary classes before any writer runs; a dotted call
-in return position now parses (`return this.helper()`); Swift string
-operators walk UTF-16 in amortised constant time; Kotlin emits
-`open class` for the header form of inheritance; a Python empty
-constructor writes `pass`; the C++ `Any` union only names classes the
-program actually emits. The TypeScript module build type-checks: a
-`sort` comparator in the serializer used `forEach`, which the ES6
-writer emits as `async`, and `Array.sort` will not take a
-`Promise<number>`. `npm run test:publish` skips the JS-engine
-conformance suites (they are not the published compiler) and runs each
-file in its own fork so a two-minute `shapes` run cannot starve the
-reporter. The gallery grew in the same window — EVG, Office,
-the book engine, Mermaid, Figma — and is not in the npm tarball.
+## [3.5.1] - 2026-09-17
+
+- **The npm README still said 3.3.0.** The package was 3.5.0; the first line
+  of `README.md` was never bumped with it, so the npm page advertised the
+  old version. npm does not rewrite a published tarball, so this is 3.5.1.
+- **This file now dates 3.4.0 and 3.5.0.** Both shipped on npm with the
+  notes below still under Unreleased, so a reader of the package changelog
+  could not tell what was in the tarball.
+
+## [3.5.0] - 2026-09-17
+
+### Added
+
+- **`rgrc install` fetches what `ranger.json` names.** `Import "pkg:…"`
+  used to resolve only against files already on disk, so a clean checkout
+  of a project that depends on `gallery/evg` had nothing to compile
+  against. The compiler now walks the graph, sparse-fetches each git
+  dependency at its pinned revision, writes it into the cache
+  (`RANGER_PKG_CACHE`, else `~/.cache/ranger/packages/<sha256>`), recurses
+  into each fetched package's own manifest, and records `rev` + `sha256`
+  in `ranger.lock`. A branch or tag is pinned to the commit it resolved
+  to. `-vendor` also writes `vendor/ranger/<name>` so a vendored project
+  needs no cache; `-frozen` fails rather than fetching what the lock does
+  not cover; `-force` refetches; `-cache=<dir>` overrides the default.
+
+- **The Git pack client is MIT, and it runs inside `rgrc`.** It sat under
+  `gallery/` and was therefore AGPL, so the MIT compiler could resolve
+  `pkg:` but not fetch it — that split cost a second npm package
+  (`ranger-pkg`) and a shell-out. The client is a clean-room read of
+  published formats (pack layout, pkt-line, smart HTTP, FIPS 180-1 SHA-1,
+  RFC 1950/1951), which is how you use the language, not an application
+  built with it. `gallery/pkg` moved to `pkg/`. `gallery/zip/Inflate.rgr`
+  and `ZipBuffer.rgr` moved to `lib/zip/` (MIT) because DEFLATE is a
+  published format and the pack needs it; the ZIP container, the writer
+  and CRC32 stay in `gallery/zip`. `compiler/PkgFetch.rgr` drives the
+  client: advertisement, want, side-band demux, pack v2 with deltas, the
+  tree walk and the content cache. `bin/git-http.mjs` is the only Node
+  left — GET and POST of bytes, because Node has no synchronous HTTPS and
+  this compiler is synchronous — and it ships in `dist/` beside `rgrc.js`.
+  `ranger-pkg` and `tools/install.mjs` are gone.
+
+- **The site root is a page about the language.** It was the playground.
+  It now says what Ranger is, what it compiles to, which platforms it
+  reaches, how the portability claims are checked, and what is in the
+  gallery. The playground moved to `/playground/`. `landing/` is plain
+  HTML, one stylesheet and one module: the logo is the bitmap tracer
+  walking the project's mark into three paths, the backdrop is an EVG
+  display list drawn on the GPU by the same painter the editors use, and
+  `landing/examples/Cart.rgr` is recompiled for Swift, Kotlin, JavaScript,
+  TypeScript, C#, C++, PHP and Rust when the site is built, so the code
+  beside each tab is what that commit's compiler writes.
+
+### Changed
+
+- **A lock entry whose checkout is still in the cache is not fetched
+  again.** A sha256 names content and the content at a commit does not
+  move. treeni-week's install went from 10s to 0.12s and needs no
+  network. `--frozen` makes the cache the only answer; `--force` ignores
+  it; a `git` or `rev` repointed in `ranger.json` still outranks the lock.
+
+- **PkgImport falls back to `ranger.lock` for a package the manifest does
+  not declare.** The lock is the whole graph; `ranger.json` is only its
+  first row. A path dependency inside a fetched package is resolved
+  against the origin that package came from (`gallery/statechart` plus
+  `../vela` is `gallery/vela` in the same repo at the same revision).
+  Imports dedup on the folded path as well as the string, so
+  `../../evg/X.rgr` and `pkg:evg/X.rgr` are one file.
+
+- **Getting started leads, not the playground.** The front page's "three
+  ways in" is a numbered path: clone and build, point the agent at
+  `AGENTS.md`, start from a gallery project, compile for the target you
+  are shipping to. The playground keeps a link in the navigation.
+
+### Fixed
+
+- **`-d=/absolute/path` wrote the tree under cwd + that path**, because
+  the working directory was joined onto it unconditionally.
+- **`compiler/bin/api.ts` is not in the tree.** It is the TypeScript
+  `build:dist:module` hands to tsc on the way to `dist/api.js`, 77k
+  generated lines that had never been tracked and went in with the 3.5.0
+  build. `dist/api.js` and `dist/api.d.ts` are what ships.
+
+## [3.4.0] - 2026-09-17
+
+The last package on npm before this one was **3.2.0**. 3.2.1, 3.3.0 and
+3.3.1 were already dated in this file and never published there, so this
+tarball is the first that carries them.
+
+On the compiler: generic classes (`class History @params(Op)`), expanded
+into ordinary classes before any writer runs; a dotted call in return
+position now parses (`return this.helper()`); Swift string operators
+walk UTF-16 in amortised constant time; Kotlin emits `open class` for
+the header form of inheritance; a Python empty constructor writes
+`pass`; the C++ `Any` union only names classes the program actually
+emits. The gallery grew in the same window — EVG, Office, the book
+engine, Mermaid, Figma, CodeGraph, Rave — and is not in the npm tarball.
 
 - **All thirty-eight of Mermaid's header keywords are drawn.** The matrix in
   `docs/MERMAID_PARITY.md` is read off Mermaid's own detector registry — the
@@ -40,10 +116,12 @@ the book engine, Mermaid, Figma — and is not in the npm tarball.
   token is a coloured speck, the slider is the viewport, a problem is a tick,
   and a click or a drag there jumps the view without moving the caret. The
   picture keeps a compact scale (two pixels a line, shrinking only when the
-  file would not fit); the pointer's place on that picture, as a fraction of
-  its height, is how far the editor scrolls. On r5 a finger on the strip
-  stays a pointer, not a line-by-line flick. A panel too narrow to spare
-  the strip hides it. The same map shows on the r5 page, on the light theme.
+  file would not fit); each letter is a faint cell at the opacity of its
+  glyph (~3 % for `.`, ~10 % for `I`, ~20 % for `R`) rather than a solid
+  bar. The pointer's place on that picture, as a fraction of its height,
+  is how far the editor scrolls. On r5 a finger on the strip stays a
+  pointer, not a line-by-line flick. A panel too narrow to spare the strip
+  hides it. The same map shows on the r5 page, on the light theme.
 
 - **FigJam boards draw.** A sticky, a shape with text, a connector and a table
   carry no children: Figma builds their layers itself and a `.jam` ships only

package/README.md

@@ -1,6 +1,6 @@
 # Ranger cross language compiler
 
-**Version 3.4.0** | Status: `experimental`
+**Version 3.5.1** | Status: `experimental`
 
 **Licensing:** Ranger-authored compiler and language sources are MIT licensed,
 unless a file says otherwise. Ranger-authored applications and technology
@@ -78,7 +78,8 @@ host.notifyPath = (path) => { /* sync view model + re-render */ };
 ## Where To Start
 
 - [Documentation site](https://terotests.github.io/Ranger/docs/) — install, first program, types, optionals, and the **generated operator reference** (838 operators, compiled from the sources of the commit that publishes the site, so it cannot drift)
-- [Online playground](https://terotests.github.io/Ranger/) — try Ranger in the browser (`playground/`, Vite + current compiler)
+- [The front page](https://terotests.github.io/Ranger/) — what Ranger is, the targets, the platforms and the gallery (`landing/`)
+- [Online playground](https://terotests.github.io/Ranger/playground/) — try Ranger in the browser (`playground/`, Vite + current compiler)
 - `README.md` - language overview, installation, and syntax notes
 - [`gallery/README.md`](gallery/README.md) - index of the application stack (AGPL): EVG, Office, DataGrid, parsers, games, and `@process` host apps
 - [`LICENSING.md`](LICENSING.md) - MIT compiler vs AGPL gallery

package/dist/README.md

@@ -1,6 +1,6 @@
 # Ranger Compiler
 
-**Version 3.0.0-beta.1** | Cross-language compiler - compile once, run anywhere
+**Version 3.5.1** | Cross-language compiler - compile once, run anywhere
 
 Ranger is a self-hosting cross-language compiler that lets you write code once and compile to multiple target languages including JavaScript, TypeScript, Python, Go, Rust, Swift, C++, Java, Kotlin, C#, PHP, and Scala.
 

package/dist/api.d.ts

@@ -1697,7 +1697,9 @@ export declare class PkgImport {
     static walkUp(env: InputEnv, start: string): string;
     static readText(env: InputEnv, dir: string, name: string): Promise<string>;
     static findChar(s: string, code: number): number;
+    static manifestChain(env: InputEnv, startDir: string, libraryPaths: Array<string>): Array<string>;
     static resolve(env: InputEnv, startDir: string, spec: string, libraryPaths: Array<string>): Promise<PkgHit>;
+    static resolveIn(env: InputEnv, manDir: string, spec: string): Promise<PkgHit>;
     static lockRoot(env: InputEnv, lockText: string, pkgName: string, manDir: string): string;
 }
 export declare class ClassJoinPoint {
@@ -3704,6 +3706,396 @@ export declare class CLIProgress {
     printFlag(flag: string, description: string): void;
     printSection(title: string): void;
 }
+export declare class GitSha1 {
+    constructor();
+    static mask32(): number;
+    static add32(a: number, b: number): number;
+    static not32(x: number): number;
+    static rotl(x: number, n: number): number;
+    static copyRange(data: Uint8Array, start: number, count: number): Uint8Array;
+    static ascii(data: Uint8Array, start: number, count: number): string;
+    static u32be(data: Uint8Array, i: number): number;
+    static hexDigit(d: number): string;
+    static toHex(data: Uint8Array): string;
+    static fromHex(hex: string): Uint8Array;
+    static hash(data: Uint8Array): Uint8Array;
+    static writeU32be(out: Uint8Array, i: number, v: number): void;
+    static hashHex(data: Uint8Array): string;
+    static objectId(kind: string, payload: Uint8Array): string;
+    static hexEq(a: string, b: string): boolean;
+}
+export declare class GitPkt {
+    ok: boolean;
+    err: string;
+    lines: Array<string>;
+    raw: Array<Uint8Array>;
+    isFlush: Array<boolean>;
+    constructor();
+}
+export declare class GitRef {
+    name: string;
+    sha: string;
+    peeled: string;
+    constructor();
+}
+export declare class GitAdvertisement {
+    ok: boolean;
+    err: string;
+    service: string;
+    caps: string;
+    head: string;
+    refs: Array<GitRef>;
+    constructor();
+}
+export declare class GitWant {
+    ok: boolean;
+    err: string;
+    sha: string;
+    body: Uint8Array;
+    constructor();
+}
+export declare class GitSideband {
+    ok: boolean;
+    err: string;
+    pack: Uint8Array;
+    progress: string;
+    constructor();
+}
+export declare class GitPktIO {
+    constructor();
+    static hexVal(ch: string): number;
+    static parseHex4(data: Uint8Array, at: number): number;
+    static hex4(n: number): string;
+    static encodeLine(text: string): Uint8Array;
+    static encodeFlush(): Uint8Array;
+    static parse(data: Uint8Array): GitPkt;
+    static parseAdvertisement(data: Uint8Array): GitAdvertisement;
+    static findRef(adv: GitAdvertisement, spec: string): string;
+    static hasToken(caps: string, name: string): boolean;
+    static joinBuf(parts: Array<Uint8Array>): Uint8Array;
+    static encodeDelim(): Uint8Array;
+    static buildWant(adv: GitAdvertisement, spec: string): GitWant;
+    static buildWantFetch(sha: string, deepen: number, filter: string, extras: Array<string>): GitWant;
+    static buildWantTrees(adv: GitAdvertisement, spec: string): GitWant;
+    static buildWantSha(sha: string): GitWant;
+    static buildFetchV2(sha: string, deepen: number, filter: string): GitWant;
+    static demux(data: Uint8Array): GitSideband;
+    static indexOfPack(data: Uint8Array): number;
+    static indexOfChar(s: string, code: number): number;
+    static trimNl(s: string): string;
+}
+export declare class ZipBuffer {
+    data: Uint8Array;
+    pos: number;
+    length: number;
+    constructor();
+    initWithBuffer(buf: Uint8Array): void;
+    initWithSize(size: number): void;
+    getPosition(): number;
+    setPosition(newPos: number): void;
+    seek(offset: number): void;
+    skip(count: number): void;
+    remaining(): number;
+    isEOF(): boolean;
+    readUint8(): number;
+    readUint16LE(): number;
+    readUint32LE(): number;
+    readBytes(count: number): Uint8Array;
+    readString(count: number): string;
+    peekUint8(): number;
+    peekUint32LE(): number;
+    writeUint8(value: number): void;
+    writeUint16LE(value: number): void;
+    writeUint32LE(value: number): void;
+    writeBytes(src: Uint8Array, srcOffset: number, count: number): void;
+    writeBuffer(src: Uint8Array): void;
+    writeString(s: string): void;
+    getBuffer(): Uint8Array;
+    getLength(): number;
+    findSignatureBackward(sig: number, startPos: number): number;
+}
+export declare class GrowableZipBuffer {
+    chunks: Array<Uint8Array>;
+    chunkLens: Array<number>;
+    chunkSize: number;
+    currentChunk: Uint8Array;
+    currentPos: number;
+    totalSize: number;
+    constructor();
+    setChunkSize(size: number): void;
+    allocateNewChunk(): void;
+    writeUint8(value: number): void;
+    writeUint16LE(value: number): void;
+    writeUint32LE(value: number): void;
+    writeBytes(src: Uint8Array, srcOffset: number, count: number): void;
+    writeBuffer(src: Uint8Array): void;
+    writeString(s: string): void;
+    getSize(): number;
+    toBuffer(): Uint8Array;
+}
+export declare class InflateHuffmanTable {
+    counts: Array<number>;
+    symbols: Array<number>;
+    maxBits: number;
+    constructor();
+    build(lengths: Array<number>, numSymbols: number): void;
+    decode(reader: InflateBitReader): number;
+}
+export declare class InflateBitReader {
+    data: Uint8Array;
+    bytePos: number;
+    bitPos: number;
+    currentByte: number;
+    dataLength: number;
+    constructor();
+    init(buf: Uint8Array, offset: number, length: number): void;
+    readBit(): number;
+    readBits(count: number): number;
+    alignToByte(): void;
+    readByte(): number;
+    readUint16LE(): number;
+    getBytePosition(): number;
+    isEOF(): boolean;
+}
+export declare class Inflate {
+    input: Uint8Array;
+    reader: InflateBitReader;
+    outBuf: Uint8Array;
+    outLen: number;
+    outCap: number;
+    fixedLitLen: InflateHuffmanTable;
+    fixedDist: InflateHuffmanTable;
+    fixedTablesBuilt: boolean;
+    lengthBase: Array<number>;
+    lengthExtra: Array<number>;
+    distBase: Array<number>;
+    distExtra: Array<number>;
+    constructor();
+    resetOutput(hint: number): void;
+    ensureCapacity(extra: number): void;
+    pushByte(b: number): void;
+    finalOutput(): Uint8Array;
+    buildLengthDistTables(): void;
+    buildFixedTables(): void;
+    decompress(data: Uint8Array): Uint8Array;
+    decompressFrom(data: Uint8Array, offset: number): Uint8Array;
+    inputPos(): number;
+    decompressStored(): void;
+    decompressHuffman(litLenTable: InflateHuffmanTable, distTable: InflateHuffmanTable): void;
+    decompressDynamic(): void;
+    copyFromOutput(distance: number, length: number): void;
+}
+export declare class GitZlib {
+    ok: boolean;
+    err: string;
+    nextPos: number;
+    constructor();
+    inflateAt(data: Uint8Array, offset: number): Uint8Array;
+    inflate(data: Uint8Array): Uint8Array;
+}
+export declare class GitObj {
+    kind: number;
+    sha: string;
+    data: Uint8Array;
+    packOff: number;
+    resolved: boolean;
+    delta: boolean;
+    baseOff: number;
+    baseSha: string;
+    constructor();
+}
+export declare class GitPack {
+    ok: boolean;
+    err: string;
+    version: number;
+    count: number;
+    objects: Array<GitObj>;
+    bySha: {
+        [key: string]: GitObj;
+    };
+    byOff: {
+        [key: number]: GitObj;
+    };
+    constructor();
+}
+export declare class GitDelta {
+    constructor();
+    static varInt(data: Uint8Array, pos: Array<number>): number;
+    static apply(src: Uint8Array, delta: Uint8Array): Uint8Array;
+}
+export declare class GitPackIO {
+    constructor();
+    static kindName(kind: number): string;
+    static parse(data: Uint8Array): GitPack;
+    static resolveDeltas(pack: GitPack): void;
+    static lookup(pack: GitPack, sha: string): GitObj | undefined;
+    static merge(a: GitPack, b: GitPack): GitPack;
+}
+export declare class GitEntry {
+    name: string;
+    sha: string;
+    isTree: boolean;
+    mode: string;
+    constructor();
+}
+export declare class GitFile {
+    path: string;
+    data: Uint8Array;
+    constructor();
+}
+export declare class GitTree {
+    sha: string;
+    entries: Array<GitEntry>;
+    constructor();
+}
+export declare class GitMem {
+    files: Array<GitFile>;
+    paths: Array<string>;
+    byPath: {
+        [key: string]: GitFile;
+    };
+    constructor();
+}
+export declare class GitStore {
+    pack: GitPack;
+    ok: boolean;
+    err: string;
+    constructor(p: GitPack);
+    takeObj(sha: string): GitObj | undefined;
+    parseTree(payload: Uint8Array): GitTree;
+    commitTree(payload: Uint8Array): string;
+    checkout(sha: string, subdir: string): GitMem;
+    walk(mem: GitMem, treeSha: string, prefix: string, want: string): void;
+    mayEnter(path: string, want: string): boolean;
+    splitSegs(path: string): Array<string>;
+    asTreeSha(sha: string): string;
+    treeAt(sha: string, subdir: string): string;
+    underSubdir(path: string, want: string): boolean;
+    stripSubdir(path: string, want: string): string;
+    baseName(path: string): string;
+    writeDisk(mem: GitMem, root: string): void;
+    dirOf(path: string): string;
+    splitPath(path: string): Array<string>;
+    fileText(mem: GitMem, path: string): string;
+}
+export declare class PkgVal {
+    kind: string;
+    str: string;
+    num: number;
+    flag: boolean;
+    keys: Array<string>;
+    vals: Array<PkgVal>;
+    constructor();
+}
+export declare class PkgJson {
+    text: string;
+    i: number;
+    n: number;
+    ok: boolean;
+    err: string;
+    constructor();
+    parse(src: string): PkgVal;
+    skip(): void;
+    value(): PkgVal;
+    object(): PkgVal;
+    str(): string;
+    num(): number;
+    static child(obj: PkgVal, key: string): PkgVal | undefined;
+    static strOf(obj: PkgVal, key: string): string;
+    static intOf(obj: PkgVal, key: string): number;
+}
+export declare class PkgDep {
+    name: string;
+    path: string;
+    git: string;
+    rev: string;
+    tag: string;
+    subdir: string;
+    constructor();
+}
+export declare class PkgManifest {
+    name: string;
+    version: string;
+    entry: string;
+    license: string;
+    deps: Array<PkgDep>;
+    ok: boolean;
+    err: string;
+    constructor();
+}
+export declare class PkgLockEnt {
+    name: string;
+    path: string;
+    git: string;
+    rev: string;
+    subdir: string;
+    sha256: string;
+    constructor();
+}
+export declare class PkgLock {
+    lockVersion: number;
+    packages: Array<PkgLockEnt>;
+    ok: boolean;
+    err: string;
+    constructor();
+}
+export declare class PkgManifestIO {
+    constructor();
+    static load(src: string): PkgManifest;
+    static loadLock(src: string): PkgLock;
+    static escape(s: string): string;
+    static dumpLock(lock: PkgLock): string;
+    static dumpManifest(m: PkgManifest): string;
+}
+export declare class PkgCache {
+    constructor();
+    static lessStr(a: string, b: string): boolean;
+    static hashMem(mem: GitMem): string;
+    static put(mem: GitMem, cacheRoot: string): string;
+    static lockFor(name: string, git: string, rev: string, subdir: string, hash: string): PkgLockEnt;
+}
+export declare class PkgFetchWork {
+    dir: string;
+    man: PkgManifest;
+    git: string;
+    rev: string;
+    subdir: string;
+    fromGit: boolean;
+    constructor();
+}
+export declare class PkgFetch {
+    ok: boolean;
+    err: string;
+    cacheRoot: string;
+    cacheOverride: string;
+    rootDir: string;
+    tmpRoot: string;
+    httpTool: string;
+    vendor: boolean;
+    frozen: boolean;
+    force: boolean;
+    lock: PkgLock;
+    previous: PkgLock;
+    seen: {
+        [key: string]: boolean;
+    };
+    lastRev: string;
+    lastMem: GitMem;
+    constructor();
+    runHttp(args: Array<string>): boolean;
+    advertise(url: string, dest: string): boolean;
+    post(url: string, body: string, dest: string): boolean;
+    fetchInto(name: string, url: string, wantRev: string, subdir: string): string;
+    storeMem(mem: GitMem): string;
+    cachedFor(env: InputEnv, name: string, git: string, rev: string, subdir: string): string;
+    install(env: InputEnv, manDir: string): Promise<boolean>;
+    oneDep(env: InputEnv, pending: Array<PkgFetchWork>, w: PkgFetchWork, d: PkgDep): Promise<boolean>;
+    static findHttpTool(env: InputEnv): string;
+    static splitPath(path: string): Array<string>;
+    static readBytes(path: string): Uint8Array;
+    static writeBytes(path: string, data: Uint8Array): void;
+    static loadPack(path: string): GitPack;
+}
 export declare class RangerDocGenerator {
     constructor();
     writeTypeDef(item: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
@@ -3863,6 +4255,7 @@ export declare class VirtualCompiler {
     fillStr(cnt: number): string;
     detectLanguageFromExtension(filename: string): string;
     isTypeScriptExtension(filename: string): boolean;
+    runInstall(env: InputEnv, params: CmdParams, cli: CLIProgress): Promise<boolean>;
     run(env: InputEnv): Promise<CompilerResults>;
     static create_env(): Promise<void>;
     static displayCompilerErrorsWithCLI(appCtx: RangerAppWriterContext, cli: CLIProgress): void;