Scarp Compiler & Runner v0.1.4 (pre-release)

Scarp Compiler & Runner v0.1.4 — Experimental Pre-release

Experimental pre-release only. These notes describe the v0.1.4 candidate;
publication requires the approved source revision and successful release
gates. Never publish a stable extension until the Scarp compiler has its
first verified stable release.

Version v0.1.4 focuses on preventing stale diagnostic information, improving
compatibility with the latest official experimental compiler, and strengthening
the release pipeline. The extension still invokes the official Scarp CLI; it is
not an independent compiler or a language server.

Verified project diagnostics

• Reject stale results: project verification detects edits to any local
  .srp source and Scarp.project manifest, including imported or previously
  clean files, while the compiler runs.
• Detect external rewrites: source snapshots include bounded SHA-256 file
  hashes. External editors and scripts cannot silently replace compiler
  results with diagnostics from an older file snapshot.
• After verification: VS Code file watchers, with a native filesystem
  notification fallback where supported, invalidate outdated project-owned
  Problems when local project files change.
• When VS Code regains focus: compare the last verified snapshots against
  disk to catch missed events. You can also run Scarp: Check Verified Project
  Diagnostic Freshness from the Command Palette.
• Independent diagnostics: unrelated standalone-file checks and other
  project roots retain their own Problems. Up to eight explicit project roots
  are monitored; evicting an old root also removes its stale diagnostics.
• Bounded work: snapshot verification has limits on total directory entries,
  source files, nesting depth and bytes. Symlinked directories and symlinks
  escaping the project fail closed rather than falsely reporting fresh results.

Checking diagnostic freshness never executes Scarp code, modifies source
files, or silently reruns verification. To refresh cleared Problems, invoke
Scarp: Verify Project manually. OS filesystem notifications are best effort;
a complete file change and reversal between snapshot checks is not guaranteed
to be detected.

Compiler integration and output

• Compiler-switch safety: changing scarp.compilerPath invalidates pending version probes, file/project verification results and terminal startup reservations. A delayed result from the previous compiler is not published as new Problems, and a delayed Run or Launch cannot open a terminal. Already completed diagnostics remain available until reverified or invalidated by source edits.

• Bounded compiler execution: command-line probes, static verification and source-navigation subprocesses escalate termination when a compiler ignores graceful shutdown after timeout or output overflow. Output limits must be positive safe integers. Regression tests cover hanging children and oversized output, without changing the interactive Run terminal behavior.

• Workspace Trust: in a genuinely untrusted workspace, keep only non-executing language coloring and local Outline available. Hide compiler-powered actions until trust is granted, and reject their direct invocation without launching the executable. Verify the behavior using a separate real Restricted Mode VS Code Extension Host CI job.

• Editor integration regressions: exercise real, compiler-produced diagnostics from an imported module with spaces in its path, ensure Problems are associated with the imported file and clear on repair, and verify that a missing configured compiler cannot launch a Run terminal or replace previous diagnostics. Test that standalone Run preserves source paths containing spaces as separate process arguments.

• Run/Launch startup safety: a file or project root reserves its terminal slot before asynchronous compiler capability checks, preventing duplicate sessions when a user rapidly invokes the command. Stop cancels pending launches; no delayed compiler result may resurrect a terminal after Stop. Verified by real Extension Host concurrent-start and delayed-probe regression tests.

• Module browser snapshot safety: check bounded local source fingerprints before and after compiler module inspection and again after Quick Pick selection and before opening a source file. Concurrent external edits, dirty buffers or stale editor content invalidate the inventory; source browsing never executes Scarp statements.

• Browse Project Symbols: use the compiler's published inspect symbols --json schema to search declarations across a single explicitly chosen Scarp project. Navigate to original source coordinates after checking file containment, saved buffers, snapshot freshness and UTF-8 span equivalence.

• Reject unsupported compiler versions, malformed symbol inventories, or source changes while the Quick Pick is open. No language server, implicit project discovery, runtime execution or persistent symbol IDs.

• Navigation results are now guarded by local source snapshots before compiler work, after inspection and after opening destination documents. Concurrent external edits to imports, source additions and out-of-date editor buffers cannot turn stale index spans into editor targets.

• Validate compiler UTF-8 byte spans against VS Code Unicode-scalar line/column translations instead of silently clamping locations.

• Go to Definition / Find All References: use the official released v0.0.6-alpha.1 static symbol and reference index on demand. Support cross-file declarations and use sites; preserve byte-span/Unicode column translation and reject unexpected output rather than guessing.

• This feature runs no Scarp statements, makes no network requests and does not promise a language server, rename, completion or incremental index. Unsaved files and untrusted workspaces are not inspected.

• Browse project modules: select an explicit, trusted project root and open its compiler-inspected entrypoint/imported module source from a Quick Pick, including import and public-symbol counts.

• Read published alpha.5 schema-v1 module JSON only. Reject malformed results, paths outside the canonical root, unsafe selected symlinks and unsaved project buffers. Never execute program statements to browse source.

• Prefer canonical scarp exec for running programs when supported; preserve
  the run fallback for older official compilers.

• Keep multi-byte UTF-8 compiler output correct across split pipe chunks.

• Validate release readiness against the actually published
  Scarp v0.0.6-alpha.1 compiler, including verify, exec, interpreter
  project launching and read-only inspect modules --json PROJECT_DIRECTORY.

• Scarp alpha.5's experimental scalar C11 emitter is a Rust embedding API,
  not a general scarp compile command. Native executable building is not
  advertised as an extension feature.

Release integrity

• Rebuild approved pre-releases from the exact GitHub tag and require the
  selected tagged commit to be reachable from the protected main branch.
• Verify the installable VSIX includes the compiled extension entrypoint,
  language grammar and configuration with the correct publisher, numeric
  version and experimental marker.
• Reject source, test fixtures, workflows, approval files, compiler checkouts,
  downloaded .vscode-test/ editor builds and release scripts from the VSIX.
• Independently rerun trusted and genuinely untrusted editor integration tests
  on the approved tagged source before packaging or publishing a VSIX.
• If a GitHub release already has an attached VSIX, compare its entire archive
  member list and uncompressed contents with the freshly verified build before
  uploading it to either registry.
• Preserve the explicit release gate: ordinary commits and PRs do not publish.
  Stable releases are blocked until the compiler is stable.

Compatibility and installation

• VS Code 1.96.0+.
• Official Scarp compiler installed separately in the workspace extension host.
  Project commands require the compiler's actual project_workflow capability;
  the release-validation compiler is v0.0.6-alpha.1.
• Marketplace and Open VSX extension ID: ScarpLang.scarp.

When the version is approved for publication, use the same verified
scarp-0.1.4.vsix for the GitHub pre-release and both registries.
All artifacts and notes must remain marked experimental pre-release.

Scarp Compiler & Runner v0.1.3 (pre-release)

Scarp Compiler & Runner v0.1.3 — Experimental Pre-release

This release adds practical Scarp editor navigation and safe, opt-in static verification when saving source files. The extension and compiler remain experimental, not stable.

Highlights

Outline and Go to Symbol in Editor

• Browse file-level funcra functions, including pure funcra and public function exports.
• Navigate bind immutable declarations, var mutable declarations, public pub bind exports, and import "..." as alias module imports.
• Navigate to the exact name selection, with declaration ranges spanning complete function bodies.
• Tolerant local parsing ignores fake declarations in strings/comments and handles source files while you type. It does not execute source code or require the compiler.

Optional Verify on Save

• Enable scarp.verifyOnSave in VS Code settings to run automatic checks when saving a local .srp file. The setting defaults to off.
• Automatic checks use only the official compiler's non-executing scarp verify --diagnostic-format=json command (supported in v0.0.5-alpha.3 and later).
• Older Scarp compilers with only an evaluating check command are never executed automatically on save.
• Rapid saves are debounced; checks for the same file are serialized, and stale diagnostic updates are discarded. Results appear quietly in Problems and the Scarp Output channel.

Official Scarp Project Workflow (Compiler v0.0.5-alpha.4)

• Scarp: Create Project invokes the official compiler to create a fresh project with Scarp.project and src/main.srp. It asks for an existing workspace parent and a new folder name; existing paths are never overwritten.
• Scarp: Verify Project validates the explicitly selected project manifest, entrypoint and imported modules without running program statements. Located compiler errors appear in VS Code Problems; manifest and unlocated errors appear in Scarp Output.
• Scarp: Launch Project starts the official interpreter in an integrated terminal and honors configured execution limits, including the new scarp.maxTextBytes setting.
• Project actions require the real compiler to report project_workflow: true through scarp diagnose --json, so alpha.3 and earlier builds are never incorrectly treated as supporting project commands.
• Multi-root workspaces require choosing the project folder; the extension does not guess an ancestor directory or interpret a Scarp.project as a package manager or native build specification.

Quality and compatibility

• Cross-platform CI builds and tests on Linux, Windows and macOS.
• Real VS Code Extension Host integration tests check Outline results and verify-on-save with the pinned official compiler.
• Existing syntax highlighting, compiler-backed Run and Verify commands, pre-release packaging checks and independent file diagnostics remain supported. Project commands use the official compiler rather than a simulated project runner.
• Official compiler compatibility target: Scarp v0.0.5-alpha.4. VS Code 1.96.0+.

Install

Use the Pre-release channel for ScarpLang.scarp on Visual Studio Marketplace or Open VSX, or install scarp-0.1.3.vsix from this GitHub Release.

You must install the official Scarp compiler separately to run or verify Scarp programs. Set scarp.compilerPath if the binary is not on the extension host's PATH.

Not yet supported

The official Scarp compiler is still alpha. The extension does not claim native executable compilation, native project builds, debugging, AI code completion, or a stable release. Stable extension publication remains blocked until the Scarp compiler's first verified stable release.

Scarp Compiler & Runner v0.1.2 (pre-release)

Scarp Compiler & Runner v0.1.2 — Experimental Pre-release

This release brings the first native Scarp syntax highlighting to VS Code and improves the reliability of compiler-backed diagnostics. Scarp and this extension remain experimental.

What's new

• Real Scarp syntax highlighting. New TextMate grammar for .srp files, aligned with the official Scarp v0.0.5-alpha.3 lexer and parser: bind, var, funcra, pure, pub, import, flow control, types, boolean literals, built-in output calls, function calls, strings and supported escapes, decimal/float/hex/binary numbers, line comments and operators.
• Independent Problems per file. Checking one source no longer clears unrelated source diagnostics. Imported-file errors retain their verification owners.
• Stale diagnostics protection. Editing a source invalidates its affected Problems, and results from a verification of an outdated document are discarded.
• Release-safe packaging. CI tests grammar tokenization using real TextMate/Oniguruma and confirms the grammar is in the VSIX. Cross-platform, official compiler and real VS Code Extension Host checks are required.

Compatibility and limitations

• Official compiler integration tested against Scarp v0.0.5-alpha.3. Install the separate compiler and set scarp.compilerPath if it isn't on PATH.
• VS Code 1.96.0 or newer, including editors compatible with VS Code extensions.
• Scarp: Verify Current File uses non-executing verify when available. Older Scarp builds fall back to the evaluating check command.
• Scarp: Run Current File runs the official Scarp interpreter. No native Scarp executable compilation, project builds, code completion, or debugging is claimed.

Install

Install the pre-release for ScarpLang.scarp from Visual Studio Marketplace or Open VSX, or install the attached scarp-0.1.2.vsix via VS Code's Extensions → Install from VSIX menu.

This is not a stable release. Stable extension publishing remains blocked until the official Scarp compiler reaches its first stable release.

Scarp Compiler & Runner v0.1.1 (pre-release)

Experimental Scarp compiler integration; verified against the pinned compiler. Native compile/build remain unsupported.

Scarp Compiler & Runner v0.1.0 (pre-release)

Experimental Scarp compiler integration. Run and check supported; native compile/build are not supported by this compiler version.