Gooo Go Ports

Gooo is an experimental language for describing program behavior and retaining how a program was built and run. This repository provides independently checked Go ports and original Gooo compositions. Start with one source change and an observable result.

First task for a coding agent

Open this checkout in Codex, Cursor or Claude Code and ask:

Follow .agents/skills/gooo-first-program/SKILL.md. Run the Gooo example, change its score threshold from 60 to 80, then save and replay a new execution. Show the actual changed result and keep my existing files.

With the supplied inputs, score 75 changes from sensor: high to sensor: low; its other three returned fields stay unchanged. The first-program skill and setup guide use compiler 83928fa and Go 1.27.2 on macOS or Linux. Reuse matching tools or follow the optional prebuilt setup. Initial source setup may download and build them. A source edit needs native execution. Saving generated Go alone is not a run. For an existing Tessl setup, use the project-local source installation to give the same first-program task to your coding agent.

Gemini CLI users can load the same instructions through the optional context extension.

If setup or execution fails, report the first failed step and diagnostic. An incomplete attempt is useful feedback. Share public source and inputs only.

Related MCP server: Epistemic Warrant Protocol (EWP)

Choose the next useful task

These examples calculate bounded facts and policy decisions. Live effects still need current host-owned authority and atomic application. Input-only OBSERVED records describe finite runs; they are not expected-output verification or a proof for all inputs. Tell us the real API or automation task you want to solve in the feedback form.

The language engine owns Gooo syntax and compiler development. This ecosystem repository owns the ports, examples and their independent Go references.

Use Gooo with a coding agent: follow the first-program skill to edit actual Gooo source, execute it and save a replay. The agent setup guide covers repository discovery in Codex and Cursor, explicit use in Claude Code, and the limits of the existing policy examples.

Install the policy comparison command: run the immutable CLI without cloning. It compares the same nine supplied facts under two fixed profiles and rechecks saved reports; Go 1.27.2 is required.

Compare API policy decisions in CI: run the existing policy review, whose Action pins module revision e723f9af6dc3 and compares nine supplied facts using the fixed original and cel-api-readonly-v1 profiles. In that pinned revision, an otherwise allowed write changes from ALLOW to ACTION_NOT_READ_ONLY, while an allowed read stays unchanged; optionally fail CI on NEWLY_DENIED. The current cel-api-readonly-principal-v1 profile preserves original base denials and also requires principal_present == true and a nonempty raw principal_value for an otherwise allowed read. For that otherwise allowed read, a false presence flag or empty raw value returns EXPLICIT_PRINCIPAL_REQUIRED; a whitespace-only raw value is nonempty because whitespace is not trimmed. These profiles cannot load arbitrary policies, and comparison results do not authorize live API actions.

Try service-policy checks from Go: open the four-file service-policy quickstart. With Go 1.27.2 already installed, follow its README to run Go generated from Gooo without a runtime Gooo compiler. Distinguish invalid input from denial, compare the same request before and after a rule change, and inspect a returned widening witness. These calls compare supplied policy facts; they do not apply a grant or call a service.

Try a Gooo path diagnostic: compare two path spellings, keep both originals, and see whether slash cleaning makes them equal. Run the supplied inputs, inspect three results and save a replay; these lexical facts do not grant access or establish router/filesystem identity.

Try automatic header diagnostics: inspect a header name and value, strictly decode external JSON, then retain both strings and the first invalid byte in a twelve-field Gooo report. No per-request human approval is needed to calculate the facts.

Compose an automatic header-addition decision: the diagnostic-header addition combines header facts, payload admission and twelve supplied request observations. Inspect sixteen fields, preserve the candidate and byte witnesses, then use a fresh Gooo-generated local host for an atomic revision check and application.

Explain an ETag before using it: strong-validator facts retain the original header, parsed tag, remaining input, validity, strength, byte lengths and a reason in thirteen fields. The Gooo composition calculates these facts automatically; it does not authorize or perform an API write.

Compare a selected If-Match value with an ETag: the compatibility core returns Go's original three-state condition as one integer field. A strict two-Text input adapter preserves invalid header grammar while refusing malformed external JSON/Unicode. Header selection, current-resource authority and applying a write remain separate.

Edit the ETag composition in your own directory: export an editable project with three current Gooo sources and a separate Go reference checker. Exporting copies source only; run the exported checker to compare all247 original inputs in seven batches. The optional CRLF mutation demonstrates a typed result difference; these finite checks do not authorize API writes.

This independent ecosystem project implements selected Go standard-library, x/net, x/image and Google UUID functions in Gooo, using independent Go references and saved replay. Its verification catalog contains 56 packages and 67 Gooo source files, including selected HTTP, Unicode, signed-decimal, literal-text, slash-path, UUID, integer, color, duration, rectangle and fixed-point APIs and importing diagnostic programs. Separate IPv4 and other sidecar examples have their own checks and are not added to the catalog's execution totals. The URL component facts sidecar implements bounded net/url.PathEscape and QueryEscape in Gooo and combines both in an original ten-field report. Preserve the input, compare path-segment and query-value encodings, and replay the result. Its strict adapter refuses malformed external JSON or more than 341 decoded UTF-8 bytes. The independent Go comparison and native receipts remain separate from the catalog totals. The RectangleIn/FitsCrop suites have completed finite native execution and saved replay with an independent raw-receipt audit; see the verification evidence. The literal-text workflow includes a reviewed 24-input native pilot and repaired checker. Its source-derived finite coverage is specified below; inspect the current CI/native reports for completed execution results. Historical evidence retains its original source and counts.

The slash-path facts sidecar adds path.Ext, path.IsAbs and an original importing six-field Report. Its separate CI check requires fresh CLI execution and saved replay for 24 boundary inputs per entry, then compares all 9,841 strings over {a,.,/} of lengths 0..8 through each fresh generated native function. Those 29,523 values are direct function comparisons, with 72 CLI and 72 saved-replay outputs counted separately. Before the decimal parser and payload-policy addition, the historical catalog contained 45 ports, 19 consumer programs, 21 consumer activities, 66 suites, 159,909 cases, 2,109 UUID-only compact batches and 7 exhaustive checks. Sidecar values are not added to those historical counters; the new two-suite extension is described below.

The IPv4 address facts sidecar adds six netip.Addr classification predicates over four integer octets and an original importing eleven-field Gooo report. It keeps every supplied integer, reports validity separately, and returns overlapping classification flags. Its CI requires 352 fresh CLI outputs and 352 saved-replay outputs, then compares a freshly generated report on 202 finite tuples with an independent Go oracle: 2,222 typed fields, including 808 original integer echoes. The expanded tuples include otherwise-positive invalid octets and values that would wrap into recognized addresses if converted to bytes too early. These generated-function comparisons are separate from the CLI layer and the existing catalog. Private addresses can also be global unicast; neither flag is a destination permission or a promise of Internet reachability. Parsing and IPv6 are outside this port.

The new IPv4 prefix queries and original equal-priority rule-pair report add two required-record query APIs and an 11-field Gooo decision. The report distinguishes invalid input and non-comparable scope/priority, and returns a canonical network witness only for overlapping opposite effects in a comparable pair. Caller scope is an opaque key, not evidence of actual context or authority. The opt-in checker requires fresh native execution and saved replay for these sources. It keeps 54 CLI outputs and 54 saved-replay outputs separate from 112 fresh generated Report calls; existing catalog counts stay intact.

The signed-decimal parser specializes Go strconv.ParseInt(text, 10, 64) in Gooo and retains original Text, exact int64 values, and syntax/range distinctions, including unsigned-overflow precedence. The original payload admission facts imports it and returns fourteen fields from seven supplied observations. It separates Go-valid signed spelling from unsigned length spelling and reports metadata, access, binding, TE, occurrence, parse, length and budget refusals in an explicit order. It needs no per-request human approval; the host must supply truthful current observations and enforce any effect. It is not HTTP framing, authorization or quota enforcement.

These two ordinary native suites add 256 parser inputs and 101 unique policy tuples, preserving the original 17 policy witnesses first. Before the path Clean/alias addition, the required roster is 46 ports, 20 consumer programs, 22 consumer activities, 68 suites and 160,266 cases; all 66 historical suites and their inputs remain unchanged. The current source partition check gives five parser batches and four policy batches: nine new batches, for 2,072 with the current combined UUID and literal Report compact CI profile (2,118 with UUID-only compact; 2,346 in legacy). The required timing roster is 2,210 records (2,256 with UUID-only compact; 2,484 in legacy). These are source partition requirements, not completed native observations. Fresh native comparison and saved replay remain required for both additions.

The lexical path alias facts example adds Go path.Clean in Gooo and an original eleven-field report. The report preserves both raw paths and explains their cleaned values, absolute/change markers and exact/clean equality. An automatic policy diagnostic can retain these facts in a duplicate-key warning under an explicit host namespace contract; equal cleaned paths do not establish permission, safe paths or router/filesystem identity. Its two appended normal suites contain 9,841 shortlex Clean inputs and 120 input pairs, for 70 suites and 170,227 cases: 47 ports, 21 consumer programs and 23 consumer activities. In legacy workspace mode, existing 68 inputs and selected source closures, seven exhaustive checks and the path-facts sidecar remain unchanged. The focused source partition check gives 77 Clean batches and four Report batches: 81 new batches, for 2,153 with the current combined compact CI profile, 2,295 timing records (final sequence 2,294). The historical PR #101 baseline bound 140 source identities; the updated verifier binds 142 in both workspace profiles. The largest raw case files are 17,823 and 29,661 bytes; the respective source-derived translated upper bounds are 13,970 and 22,680 bytes. These are measured source partition requirements. The historical workspace passed the full 70-suite comparison and saved replay in PR #101 and its merged-main CI. Those completed checks do not establish acceptance of the new workspace profile below. Both entries have portable execution and saved-replay examples in the guide.

The header facts example adds the bounded x/net ValidHeaderFieldName and ValidHeaderFieldValue predicates and an original importing report. It preserves both decoded strings, validity, first-invalid byte witnesses and whole-input descriptive flags. A strict external JSON helper refuses malformed or unsupported input before the Gooo invocation. Its frozen corpus adds 232 name cases, 232 value cases and 476 pairs: 940 new cases across three suites, bringing the required source roster to 73 suites and 171,167 cases. The preceding 70 suites and seven exhaustive checks remain required. Current source native execution, saved replay and CI remain required; earlier completed runs and the historical partition/timing numbers below do not validate this addition. The report is suitable for an explicit automatic header policy and does not require a human decision to compute. HTTP framing, authority and actual effects remain host responsibilities.

The canonical header-key composition separates canonical Text from name validity. It retains the original name, canonical form, change flag, byte lengths and first invalid byte witness in eight required fields. fOO-bAr becomes Foo-Bar; x bad remains unchanged and invalid, with byte offset 1 and octet 32. The port reproduces bounded net/textproto.CanonicalMIMEHeaderKey Text content in Gooo and imports the existing Gooo token predicate. No per-case human approval or HTTP effect is introduced. Two appended normal suites retain all 1,059 input occurrences each, including five repeated keys; independent Go references and saved replay remain required. The preceding 74-suite/171,217-case/2,181-batch prefix is preserved. The completed historical roster contains 76 suites, 173,335 cases and 2,240 batches. The ETag extension below requires a new full run against the updated source tree; earlier observations do not validate the new addition.

The ETag port exposes bounded adaptations of Go's private scanETag and etagStrongMatch helpers. The original strong-validator facts composition keeps raw header validity separate from parsed-tag strength and leftover content. For example, "a", "b" has a parsed first tag and trailing content; W/"a" is complete but weak. Neither is reported as a single strong validator. All operands are decoded Unicode-scalar UTF-8 Text of 0–1,024 bytes; NUL, control characters and invalid ETag grammar remain part of the test domain. The raw strong-match API deliberately preserves Go's helper semantics, including grammar-invalid equal strings beginning with a quote.

Three appended suites retain 192 scanner occurrences (190 distinct strings), 31 raw comparison pairs and 24 thirteen-field reports. Their focused native execution and saved replay cover all 247 inputs in seven batches (3/2/2), with 727 returned scalar values per layer compared with an independent Go reference. The ETag extension required 79 suites, 173,582 cases, 2,247 batches and 2,407 timing records, binding 251 current source files. Full CI and all seven existing exhaustive checks remain required. These are finite diagnostics; current-resource matching, authorization, atomic writes and full If-Match processing are outside this port.

The original diagnostic-header addition adds one importing AssessAddition activity after the preceding 73 suites. It combines the header and payload reports with a twelve-field RequestFacts record to return sixteen typed fields: candidate strings, status/reason, imported facts, first invalid bytes, the observed revision and eligibility. No per-case human approval is needed to compute the decision. The new suite retains all 50 frozen cases in seven fixed batches of at most eight rows; actual Go serialization must fit both raw and translated limits before each CLI launch. The required roster is 74 suites, 171,217 cases and 2,181 batches, with the original 73-suite 171,167-case/2,174-batch prefix unchanged. Fresh public native/replay acceptance is required for this source; private results are not substituted. A later CI stage extracts the unchanged generated program from those fresh receipt bytes, compares all 50 Go-reference outputs, and checks a local atomic host. The host example does not implement a distributed transaction, persistent ledger or authenticated request source.

Full CI selects --workspace-profile dependency-closure-v1 independently of the existing --case-profile uuid-and-literal-report-compact-v1. The workspace profile starts with each suite's historical selected workspace, then follows imports over whole selected packages in their original order. Before the header addition it narrowed 56 of the 70 manifests; the 14 already isolated UUID, literal-text, decimal and path manifests stay exact. Omitting the option, or choosing legacy, preserves the historical workspace and emits no workspace_profile metadata. The explicit profile appears in both the summary and timing header. Timing still binds all 140 existing inputs plus the selector and its tests, for 142 historical source identities, and prints each suite's actual source_set and source_set_sha256. For that historical roster it did not reduce the required 70 suites, 170,227 cases, 2,153 batches, 2,295 timing records or seven exhaustive checks. The new header roster requires a fresh partition measurement.

A local serial ABBA pilot using legacy case-wire serialization on go/net/http:StatusText and app/color-inspector:InspectRGB ran 208 fresh execute/saved-replay commands. Mean command sums were 19.88 seconds with the historical workspace and 17.13 seconds with the narrower workspace. The runs shared a Go cache and include order and cache effects. These two-entry observations establish neither a hosted CI speedup nor acceptance of the other 68 entries. Fresh full-roster native comparison, saved replay and all existing CI sidecars remain required for this profile. The native execution job uses ubuntu-24.04 to keep its selected runner image explicit.

The original automatic redelivery policy uses nine supplied facts to return fifteen fields, including every original input, a next action and its reason. It can select an eligible attempt, stop, refresh evidence or look up an already applied operation without per-case human approval. The application must establish current facts and atomically claim before dispatch; this example supplies no sender, ledger or host adapter. Its separate CI requires 16 fresh CLI outputs and 16 saved-replay outputs, then compares all 12,288 valid tuples through the fresh Gooo-generated function with an independent Go reference and saved-row readback. Each full comparison checks 184,320 typed fields and 110,592 original echoes; full-domain individual CLI/replay counts stay zero. The 36 strict wire and 18 receipt-tamper refusals are also separate from the existing port, path-sidecar and Node/Wasm counters. These finite checks do not establish production delivery safety or a speedup.

The original Retry-After facts prototype composes the existing decimal parser with six supplied observations to return fourteen typed cooldown facts. Its portable headless verifier compares113 inputs with a fresh independent Go reference, replays saved receipts and checks eleven receipt mutations. The starter's60-second delay and59 elapsed seconds produce WAIT with one remaining second. READY_TO_REASSESS requires current facts and a fresh policy assessment; it never grants dispatch authority. This separate full-only CI sidecar leaves the82-suite port catalog unchanged.

The separate Agent Mesh service-pattern example adds a bounded adaptation of MatchServicePattern and an original three-field comparison for one supplied request before and after a pattern change. Its 63 matcher cases (including 12 upstream tests) and 16 original impact cases are separate from the 56 authored APIs and the native catalog above. WIDENED means that this supplied request became allowed; it is not a global grant-inclusion proof or a current authorization. Gooo computes the matches and impact without per-call human approval; the host owns trusted facts and any actual effects. The original single-pattern refinement analyzer also compares the two whole patterns within that bounded grammar. It returns a recognized subset rule or a concrete newly admitted request checked by the imported matcher. For example, changing mcp://*.x to mcp://a.* produces mcp://a.y: testing only the shared request mcp://a.x would miss the widening. This pure decision does not apply a policy change or establish caller authority. Its default Gooo workspaces validate the input grammar themselves and distinguish INVALID_INPUT from a computed denial. See the checked workspace migration for the explicit result schemas and raw compatibility routes.

The automatic policy-change example composes these Gooo decisions with a Go host that owns current state. It applies a change to one in-memory grant only when the candidate is a recognized subset, one configured required request stays allowed, and the writer and revision are still valid. No per-change human approval is required. The demo also shows a stale proposal, a refused expansion, and recovery of a discarded response by operation ID.

The appended selected If-Match core retains all284 original input occurrences in five batches. The preserved80-suite prefix has173,866 cases,2,252 batches and2,414 timing rows; its original79 suites retain173,582 cases and2,247 batches. The separate LastIndex port and final-marker consumer append1,783 cases in53 batches. The current required roster is82 suites,175,649 cases, 2,305 batches and2,471 timing rows. Current-source hosted checks must establish these totals independently of private or historical receipts. Seven existing exhaustive dispatches remain unchanged. See the domain, strict input route and reference mapping.

Start here

The older ValidRune import walkthrough remains fixed to preview.2 and its own compiler. Use the current path walkthrough above for the 83928fa compiler and Go 1.27.2.

You can also try 21 library functions in the browser. The library tools and tutorial run fixed, precompiled programs. The experimental code editor uses the actual pinned Gooo compiler library as WebAssembly to generate Go from edited source. It loads about 22 MB, accepts one file up to 64 KiB, and does not support package imports or model-backed generation. Use the local toolchain to execute modified Gooo programs. Browser compilation reports retain their engine UNBOUND_LOCAL_SOURCE provenance; the separately hashed bridge does not turn them into native execution receipts.

Compare Gooo with generated Go without setup: four saved CLI observations show a conditional body, a changed return, one selected activity, and a rejected body. This read-only page preserves the exact source and output from the linked pinned Linux verification; it does not compile edited source or execute the generated Go.

Experimental tooling: Compiler Explorer adapter and Linux verification for inspecting generated Go. Upstream hosted support is under review.

한국어 안내: 설치 없이 튜토리얼 실행, 브라우저에서 소스 수정·Go 생성, 로컬에서 코드 수정, 다른 프로젝트에 가져오기 중에서 시작하세요.

Optionally install the experimental Claude Code adapter for a requested Gooo ETag source edit. Export a separate project and compare the edit against Go using the pinned tools.

Run and edit locally

Start by running and editing the small Gooo tutorial. Use Git, a POSIX shell and a Go installation that supports toolchain selection on macOS or Linux. Choose either the prebuilt or source-build setup below.

Optional prebuilt setup: the v0.6.32-dev release matches this checkout's compiler pin. Choose its macOS amd64/arm64 or Linux amd64 archive. Host Go 1.27.2 is still required for native execution. Download the archive and SHA256SUMS to a new empty directory. For macOS arm64, confirm this hash also appears in SHA256SUMS. In that directory, verify before extracting:

set -eu
printf '%s  %s\n' '987b2910e4830ee2080d4f3a50b27bd068c63a3cfb9e60d1eba38deb7dc68c14' 'gooo-darwin-arm64.tar.gz' | shasum -a 256 -c -
mkdir extracted
tar -xzf gooo-darwin-arm64.tar.gz -C extracted

From the repository root, set these paths to the unpacked executable and a new identity file in that download directory. Stop if either check fails:

set -euC
export GOTOOLCHAIN=go1.27.2 GOWORK=off
compiler_executable=/absolute/path/to/unpacked/gooo
identity_json=/absolute/path/to/new-download/build-identity.json
"$compiler_executable" version --build --json > "$identity_json"
go run ./tools/bootstrap-check.go "$identity_json"

The identity check requires the exact compiler revision and version in upstream.json, Go/native Go go1.27.2, CLEAN_VCS and vcs_modified: "false". Keep existing .gooo, .compiler and receipts untouched. After validation, use "$compiler_executable" instead of ./.gooo in the run/replay commands and skip bootstrap. A checksum or identity failure must be reported before continuing.

To build the pinned compiler from source instead, run from the repository root:

export GOTOOLCHAIN=go1.27.2
export GOWORK=off
./tools/bootstrap.sh
./.gooo package execute --inputs examples/learn-gooo/inputs.json \
  learn-gooo.workspace.json

The four examples include score 75 returning sensor: high. In examples/learn-gooo/main.gooo, change the one if score >= 60 condition to if score >= 80, then rerun the last command: score 75 now returns sensor: low; its other three fields stay unchanged. Follow the edit-and-replay steps to save a new execution record and replay it. Setup downloads the pinned compiler and may also download Go 1.27.2, depending on the installed toolchain. Full native port verification is a separate check.

Upgrading an existing checkout: bootstrap preserves an older .compiler and refuses to replace it. Use a fresh checkout in a new directory, or move both .compiler and .gooo into a separate backup directory before running bootstrap. Keep the old compiler with its saved execution records; this upgrade does not claim that every receipt from an older compiler can be replayed by the new one.

The original 3,147-case corpus is unchanged. A Unicode inspector adds 334 Go-reference cases and 12 explicit domain-rejection cases; six unary byte-domain functions cover all 256 inputs. Color ports and their consumer add separate reference and rejection cases, detailed below. Other domains use finite boundary cases and samples. This is an independent experimental port, not a complete Go package implementation or an official Google/Go project.

The native fixed-point pixel bounds example converts caller-supplied Q26.6 subpixel bounds outward to integer pixels and clips them with the existing rectangle port. It keeps raw empty selections empty, reports invalid/overflowing requests explicitly, and preserves upstream int32 wrap behavior in the two low-level Floor/Ceil ports. It performs no font or image rendering and does not change the browser tools.

Try the browser demo to run 21 HTTP, Unicode, byte, color, and duration functions without installing a compiler. It executes a precompiled Gooo program as WebAssembly; it is not an editor for compiling arbitrary source. The page includes the Gooo source, unmodified generated Go, execution receipts, and an optional reference-check button. Use Copy link to this input to share an exact function input. Opening a link runs it once in the recipient's browser when the compiled program matches; a changed program restores the inputs and waits for Run function. Links carry inputs, not trusted results. Enter three RGB or four CMYK channels (integers from 0 to 255) to see named output channels and an RGB preview. The native RGB → CMYK → RGB inspector reports converted channels, recovered RGB values, and any integer round-trip differences. Choose bits.RotateLeft8 to enter a byte and a signed rotation count and see the eight bits before and after. The native byte rotation inspector also restores the byte and checks its one-bit count. Choose time.Duration.Round or time.Duration.Truncate to adjust an exact signed nanosecond duration to a chosen multiple. The native duration quantizer returns both results and their adjustments. Zero or negative multiples preserve the original duration. Choose unicode.IsSpace to check whether one code point is whitespace according to Go and Unicode 17.0.0. Enter its numeric value or paste one code point without trimming. The native whitespace inspector also reports scalar validity, ASCII whitespace membership, and UTF-8/UTF-16 lengths. This classification does not determine whether a character is visible or safe. See the reproducible Go–JavaScript whitespace comparison for the U+0085 and U+FEFF differences in blank-input checks.

The Unicode text inspector combines six existing compiled Gooo functions for a whole pasted input. It shows each code point's original UTF-16 position, scalar validity, Go whitespace, letter and decimal-digit membership, and UTF-8 / UTF-16 encoding lengths. CR and LF remain separate; combining and joined sequences are shown as their constituent code points. The browser decodes the received UTF-16 text and displays the Gooo results. Download a completed inspection as JSON to retain the exact input, returned values and program version for a bug report or test case. This is a browser application using existing ports, not a new Gooo string API. See input handling, limits, and verification.

The native identifier character classifier adds complete Unicode IsLetter and IsDigit ports. It distinguishes letters, decimal digits and underscore for one identifier character. A reproducible generator preserves every pinned range and stride; these two ports are available in native Gooo workspaces and in the 21-function browser demo. Try the text inspector’s Letters + decimal digits example to compare 가, ١, 𝟎, ², ¼, Ⅷ and a combining accent. These per-character categories do not validate a whole identifier. To use these ports outside this repository, follow the complete Unicode import walkthrough. It builds a separate application from a fixed snapshot, copies both required source files, and saves an execution record for replay.

The native byte-search example imports strings.IndexByte to find one byte in valid UTF-8 Text of at most 1,024 bytes. Its Gooo loop checks the length before each byte access and preserves Go byte offsets, including matches inside a multibyte character. The returned record shows the offset, whether a match was found, the original needle domain and byte length. An Integer outside 0..255 returns -1 as a separate extension. This is not whole-string Unicode searching, arbitrary Go byte-string support, or the whole strings package; the existing 21-function browser tools are unchanged.

The native literal-text report imports strings.Index and strings.Count. Give it a diagnostic snippet and phrase to receive the first byte offset, match count and original input echo in exportable JSON. Each decoded valid UTF-8 argument can contain NUL and multibyte characters and is limited to 1,024 bytes. Matching is case-sensitive and non-overlapping; an empty phrase returns offset 0 and Unicode code-point count plus one. Unicode normalization, arbitrary-byte Go strings and regular expressions are outside this API. The literal search page runs this unchanged importing consumer as a separate precompiled WebAssembly program. Inputs stay local. It shows the captured strings and the decoded strings sent to Gooo, including explicit replacement of lone UTF-16 surrogates with U+FFFD. The downloaded JSON is a browser observation, separate from the checked native report. The existing 21-function dispatcher and Unicode inspector are unchanged.

The native final-marker report adds strings.LastIndex through a separate versioned eight-field entry. For "aaaaa" and "aa", it returns first position0, last position3 and non-overlapping count2. LastIndex includes overlapping matches and returns the text's byte length for an empty phrase. Both arguments retain the same decoded valid UTF-8 Text limit of1,024 bytes. Its1,694 port cases and89 consumer cases use independent Go reference outputs, fresh native execution and saved replay; the original seven-field report and its source closures remain unchanged. These are required finite checks, not a claim that an untested source revision has passed or that diagnostic text is trustworthy.

The native UUID format inspector imports Google's github.com/google/uuid v1.6.0 Validate port. It accepts the original hyphenated, URN, braced and plain-hex forms over valid UTF-8 Text of at most 1,024 bytes, preserving exact error text and the original length-error classification. The inspector adds the original UTF-8 byte length. All checks and error formatting run in Gooo, including a multibyte character cut by the first-nine-byte URN prefix. This is a format check, without UUID generation or parsing into a binary UUID. See API mapping, source and limits. The existing browser library tools remain unchanged; this port and inspector run locally.

The native UUID canonical parsing example uses a separate ParseCanonical Text API to preserve Google's Parse return value through UUID.String(), plus the original error and length-error class. An error can still return a nonzero UUID value, so check parsed before using canonical_uuid. The parser's permissive 38-byte wrappers differ from the Validate format check. The separate browser inspector runs this unchanged activity and exports unsigned observations. See the API mapping and scope.

The native simple case-fold comparison imports unicode.SimpleFold to compare two rune values and show each value's next member in its Unicode simple-folding cycle. For example, K, k, and the Kelvin sign K belong to one three-member cycle. This preserves the pinned Go rules for special cycles and invalid Unicode values; it is a per-rune API, not whole-string folding, normalization, or locale-sensitive text comparison. The browser tools continue to provide their existing 21 functions.

The native case-mapping inspector shows one rune's uppercase, lowercase and titlecase results. The four ports unicode.To, ToUpper, ToLower and ToTitle share the complete pinned case table in Gooo. For dž, uppercase is DŽ while titlecase is Dž. The returned record keeps the original integer and distinguishes the int32 rune domain from valid Unicode scalars. These are simple rune mappings, without locale rules or multi-character expansions such as ß to SS.

The native alpha matte example imports color.NRGBAToRGBA to show premultiplied 16-bit channels, then composites one foreground pixel over an opaque RGB background. For example, red with alpha 128 over white becomes (255, 127, 127). The example preserves Go's encoded-channel integer arithmetic; it does not decode images or perform linear-light blending. All original foreground channels are accepted in the byte domain, including hidden RGB with zero alpha. A channel outside that domain is rejected before arithmetic. Both the port and this importing example are native-only.

The native YCbCr round-trip inspector imports Go's RGBToYCbCr and YCbCrToRGB ports. It preserves the full byte range and the pinned Go fixed-point rules, and shows the recovered RGB channels and their differences. Pure red (255, 0, 0) returns as (254, 0, 0) in this conversion. Use the saved records to investigate integer color conversion; the example does not read image files or perform JPEG compression or chroma subsampling.

The native crop planner imports the rectangle package and clips a requested region to image bounds. Rectangle records preserve all four signed 64-bit coordinates, including reversed and empty rectangles. The Go Min.X, Min.Y, Max.X, Max.Y fields map to min_x, min_y, max_x, max_y; the port does not normalize them. Try the same importing program in the browser crop planner: enter bounds and a requested region to get exact intersection coordinates and whether the result contains pixels. It preserves reversed and empty inputs, exclusive maximum edges, and the full signed 64-bit coordinate range. It does not load or modify image files. This separate browser program composes the existing RectangleIntersect and RectangleEmpty ports; it adds no new port and leaves the 21-function demo's input and shared-link formats unchanged.

The native FitsCrop example returns whether a nonempty requested rectangle already fits inside the supplied bounds. It imports RectangleEmpty and the new RectangleIn; it does not clip or normalize the request. Go considers every empty or reversed receiver inside any rectangle, so RectangleIn can return true while FitsCrop returns false. Equal exclusive maximum edges are allowed, and all four coordinates retain their original signed 64-bit values. This example runs locally; the browser programs are unchanged.

The experimental drag-selection crop planner interprets the requested rectangle as two unordered drag corners. Choose Two-corner selection in the browser crop planner: (200,200) to (100,100) selects the same region as the reverse direction. A separate compiled DragCropPlan program imports RectangleCanon, then clips to the original bounds. The default Keep rectangle order mode continues to run CropPlan with its original reversed-input behavior. Neither mode normalizes image bounds or processes image files; the 21-function dispatcher is unchanged.

To learn the language from a small program, try the score-and-label tutorial. Change two inputs, inspect the four returned fields, and read both Gooo source files on the page. Download the same project and follow its native instructions to change the code locally. The browser runs this fixed program as WebAssembly and preserves exact 64-bit scores. The example accompanies a pending Learn X in Y Minutes contribution; it is separate from the Go port counts and does not imply that site's endorsement.

The separate offline decision-policy experiment applies explicit tenant, action, integer-limit and expiry rules to synthetic Choice proposals. It compares Gooo with an independently written Go policy and manual expectations, then counts calls to a mock operation. It is a small example for discussing policy-review and incident-reproduction work, with no live model API, real export or production-security claim. Its cases are separate from the port compatibility counts. The guide includes a focused request for workflow feedback.

The CEL API policy example adapts one pinned Google CEL codelab rule into ports/cel/scalar_access.gooo. An original Gooo consumer imports that rule and combines it with explicit authentication, tenant and action facts. The caller receives a decision and reason without a human approval step. The example preserves the typed protobuf rule's missing-field behavior and compares it with the real CEL runtime. Workspace execution accepts strings up to 1,024 bytes; the separate generated native JSON adapter accepts up to 65,536 bytes. These finite checks are separate from the 42 API compatibility counts. Authenticating supplied facts and enforcing effects remain application responsibilities; this is neither a complete CEL implementation nor a production authorization service.

The native example also supports keeping an API decision in a private file and verifying it later with VerifyAPIProof. Its Go host example re-evaluates all fifteen observations through the generated Gooo policy and requires the same complete bound source generation. A changed decision or another generation is rejected automatically. This checks historical consistency; current identity, current permissions and external effects still belong to the host. See the save and replay walkthrough.

The separate AutoBot action-line resolver ports one pinned Python rule into Gooo. Supply canonical stored/default, baseline, role and store/scope facts; retain all eight result fields and the exact reason. Its input converter checks the external JSON boundary without calculating a decision. The finite204-case check is separate from the ordinary80 suites and Go API counts. It does not access an AutoBot store, retain historical policy artifacts, implement approvals or authorize effects; read the raw-entry preconditions and Apache-2.0 attribution.

For a fixed snapshot, choose an experimental release. Each release page lists its included tools and separate source, execution/replay evidence, and standalone browser archives, with licenses, provenance, and checksums. Downloads do not require a GitHub login. Follow that version's download and verification instructions; the live demo and main branch can be newer than the chosen snapshot.

If loading or running fails, report a problem with the page URL or command and what happened. A working demo or shared input link is not required. See reporting guidance for useful details.

Go로 작성된 오픈소스의 동작을 Gooo 함수로 이식하고 원본과 비교하는 공개 실험 저장소입니다. 현재 Go 표준 라이브러리, x/image와 Google UUID의 HTTP·Unicode·IPv4 분류·prefix 질의·십진수 파싱·문자열 검색·분할·슬래시 경로·UUID 형식 검사·파싱·8비트 정수·색상 변환·시간 간격·사각형·고정소수점 API 56개와, 별도 URL 구성 요소 인코딩 API 2개를 소스로 표현합니다. Go 소스를 분석해 타입·경계값·실패 동작을 명시하고, 계산은 ports/**/*.gooo에 구현합니다. Go 검증 도구는 원본 함수 호출, 입력 전달, 결과 비교와 실행 기록 저장을 맡습니다.

Gooo 컴파일러를 사용하는 독립 생태계 프로젝트입니다. 현재 언어로 동작하는 라이브러리와 다음 이식을 막는 최소 재현 사례를 함께 쌓아 언어 개발에 간접적으로 기여합니다. Google·Go 프로젝트의 공식 이식판은 아닙니다.

이식한 함수

원본의 rune 입력은 int32 범위를 Gooo Integer로 전달합니다. byte 호환 범위는 0..255입니다. 묵시적으로 정수 폭을 줄이지 않습니다. RuneStart의 범위 밖 입력은 Gooo 확장 동작으로 false를 반환하지만 원본과의 동등성 집계에는 넣지 않습니다. IsSpace, IsLetter, IsDigit도 int32 밖의 정수는 별도 확장 계약으로 false를 반환합니다. int32 안의 음수, 서로게이트, Unicode 최댓값보다 큰 수는 원본 API 입력이며 결과는 false입니다. SimpleFold는 int32 안의 음수·서로게이트·Unicode 범위 밖 입력을 Go처럼 그대로 반환합니다. int32 밖 Integer도 그대로 반환하는 별도 확장 계약이며, Go rune 변환이나 원본 동등성 집계에 넣지 않습니다. 두 rune 비교 예제의 in_rune_domain은 int32 범위를 뜻합니다. 유효 Unicode 스칼라 판정이 아니며, 같은 잘못된 Unicode 값 두 개도 같은 고정점으로 비교됩니다. İ·ı는 각각 고정점이고, K → k → K → K 등의 특수 순환을 단순 소문자 변환으로 대체하지 않습니다. To의 첫 인수는 0(대문자)·1(소문자)·2(제목형)이며, 다른 값이면 rune 범위 검사보다 먼저 U+FFFD를 반환합니다. 유효한 case와 세 단항 변환은 int32 안의 잘못된 Unicode 값을 그대로 보존하고, int32 밖 입력도 별도 identity 확장으로 유지합니다. 전체 문자열이나 지역별 변환이 아니며, 검사 예제는 원입력과 세 결과를 함께 반환합니다. NEL(U+0085)은 공백이고 BOM(U+FEFF)·ZERO WIDTH SPACE(U+200B)는 공백이 아닙니다. JavaScript의 \s·trim과는 다른 판정이며, 보이지 않는 문자 전체를 탐지하지 않습니다. go/math/bits의 여섯 함수는 바이트 영역 밖에서 별도 확장 동작인 -1을 반환합니다. Go의 byte 변환처럼 입력을 잘라서 계산하지 않습니다. 0의 앞·뒤 0 개수는 원본과 같은 8입니다. 색상 변환도 모든 채널을 먼저 검사하며 범위 밖에서는 레코드의 모든 성분을 -1로 반환합니다. NRGBAToRGBA는 RGB가 알파보다 크거나 알파가 0이어도 원래 NRGBA 입력으로 받습니다. 알파 합성 예제는 이 포트를 사용해 불투명 배경 위의 한 픽셀을 합성하고 중간 16비트 성분과 최종 8비트 RGB를 함께 보여줍니다. Go의 정수 버림을 보존하며, 이미지 파일 처리나 선형 광량 공간의 합성을 구현한 것은 아닙니다. 원본의 정수 나눗셈 순서를 유지하므로 왕복 변환이 원래 RGB와 항상 같은 것은 아닙니다. YCbCr 변환은 Go의 JFIF 계수와 채널 포화를 보존합니다. 역변환은 Y′ * 65793을 그대로 사용하며 음수·상한 밖 분자를 먼저 처리해 signed shift를 안전한 나눗셈으로 옮깁니다. 두 파일 ports/image/color.gooo와 ports/image/ycbcr.gooo를 함께 가져와야 합니다. StatusText·RotateLeft8·To의 Go int 입력 비교는 int가 64비트인 amd64·arm64에서 실행합니다. 회전 수는 int64 전체를 보존하며, 나머지를 먼저 계산해 최솟값의 부호 반전을 피합니다. 원본 RotateLeft8의 입력에 무관한 실행시간 보장은 분기·산술로 구현한 포트에 계승하지 않습니다. 시간 간격의 두 입력은 signed int64 나노초 전체 범위입니다. 단위가 0 이하이면 원래 값을 반환하며, 정확한 중간값은 0에서 멀어지는 쪽으로 반올림합니다. 반올림 결과가 범위를 넘으면 int64 최솟값·최댓값으로 포화되므로 결과가 단위의 배수가 아닐 수 있습니다. 사각형은 Go의 Min.X, Min.Y, Max.X, Max.Y를 min_x, min_y, max_x, max_y로 표현합니다. 각 좌표는 amd64·arm64의 Go int 전체 범위를 유지합니다. 변이나 꼭짓점만 접촉하면 겹치지 않으며, 빈 교집합은 네 좌표가 모두 0입니다. 둘 다 빈 사각형이면 합집합은 두 번째 입력의 좌표를 그대로 돌려줍니다. 좌표를 정렬하거나 범위를 줄이지 않습니다. HTTP 서버, UTF 인코딩, Go time·image 패키지 전체의 이식은 아닙니다.

실행하기

브라우저 데모는 설치 없이 21개 함수를 실행합니다. 실제 Gooo importing 예제를 고정 컴파일러로 생성하고, 생성된 Go를 한 글자도 수정하지 않은 채 WebAssembly로 빌드합니다. 입력·출력 경계의 Go bridge는 정수 범위 검사와 직렬화만 맡습니다. 임의 Gooo 소스를 브라우저에서 컴파일하지는 않습니다. HTTP 입력은 int64, rune 입력은 int32, byte·색상 채널 입력은 0..255로 제한하며 범위 밖 입력을 거부합니다. 회전 수는 signed int64 전체 범위이며 음수는 오른쪽 회전입니다. 시간 간격과 단위도 signed int64 나노초이며 0 이하 단위를 포함합니다. 숫자 입력란의 값은 JavaScript Number를 거치지 않고 십진수 문자열로 전달합니다. 공백 붙여넣기 보조 입력은 정확히 한 코드 포인트를 숫자 입력란에 채우며, 공백 판정은 Gooo가 수행합니다. RGB는 3개, CMYK는 4개 채널을 각각 전달하며 채널을 하나의 정수에 묶거나 잘라내지 않습니다. 결과에는 채널 이름과 정수 값이 표시됩니다. RGB 미리보기는 입력 또는 반환된 RGB를 보여주며 색상 프로파일이나 프린터 출력 보정은 수행하지 않습니다.

Copy link to this input으로 함수와 입력을 공유할 수 있습니다. 같은 프로그램이면 받는 브라우저에서 한 번 실행하고, 프로그램이 달라졌으면 입력을 복원한 뒤 Run을 기다립니다. 링크에는 입력 문자열, Wasm SHA-256, 원본 리비전만 담으며 결과를 저장하지 않습니다. README만 바뀌어도 Wasm이 같으면 실행할 수 있습니다. 잘못된 링크는 실행을 막고 새 예제로 돌아갈 수 있게 표시합니다. 클립보드가 차단되면 복사할 링크를 화면에 보여줍니다. 일반 #workbench 링크와 기존 13개 함수의 #gooo-share?v=1&... 링크를 유지합니다. 색상 링크는 모든 채널을 담는 v=2 형식입니다. 이전 프로그램에서 만든 링크도 입력을 복원하지만, Wasm 해시가 달라졌으면 자동 실행하지 않습니다.

데모를 소스부터 재현하려면 Git으로 받은 저장소에서 Go 1.27.2와 Node.js 22 이상을 사용합니다. 브라우저 빌드는 Git 리비전을 기록하므로 .git이 없는 소스 압축본은 이 절차에 사용할 수 없습니다. 배포된 browser-demo 압축본은 안의 README에 따라 site/를 HTTP로 제공하면 되며 컴파일러 설치는 필요하지 않습니다.

./tools/bootstrap.sh
go run ./cmd/build-demo --out out/browser
node tools/browser-smoke.cjs out/browser/site
node tools/drag-crop-browser-smoke.cjs out/browser/site
node tools/tutorial-browser-smoke.cjs out/browser/site
node tools/literal-search-smoke.cjs out/browser/site
node tools/uuid-parse-smoke.cjs out/browser/site
node tools/browser-codegen-smoke.cjs out/browser/site/codegen out/browser/codegen-evidence
node --test tools/share-link.test.cjs tools/share-app.test.cjs
python3 -m http.server 8766 --bind 127.0.0.1 --directory out/browser/site

마지막 명령은 Python 3가 필요하며, 실행 후 http://127.0.0.1:8766을 엽니다. 소스 편집기는 /codegen/에 있습니다. 생성 검사에서는 16개 예제와 저장되지 않은 새 편집 소스를 실제 컴파일러·WebAssembly와 비교하며, 생성한 Go는 실행하지 않습니다. 편집기만 빌드하려면 새 출력 경로와 --codegen-only를 사용하면 됩니다. UUID 파싱 화면만 빌드하려면 --uuid-parse-only와 새 출력 경로를 사용하고, 그 경로의 site/를 위와 같이 HTTP로 제공합니다. 이 두 전용 빌드 모드는 함께 사용할 수 없습니다. 다른 정적 HTTP 서버를 사용해도 됩니다. --out 디렉터리는 새 경로여야 합니다. 여러 배포본을 로컬에서 열 때는 버전별 디렉터리와 URL을 유지하세요. 같은 URL의 파일을 교체했다면 캐시를 무시하고 새로고침해 HTML과 스크립트를 다시 받습니다. 실행 파일·메타데이터·비교 입력은 브라우저 캐시를 재사용하지 않고 요청합니다.

API 정책 비교 화면만 재현하려면 Go 1.27.2와 Node.js 22를 선택한 뒤 새 출력 경로를 사용합니다. 이 전용 모드는 기존 Gooo 생성 Go와 두 고정 정책을 사용하며, Gooo 컴파일러를 실행하지 않습니다. 다른 전용 빌드 옵션과 함께 사용할 수 없습니다.

GOTOOLCHAIN=local GOWORK=off go run ./cmd/build-demo --api-policy-only --out out/api-policy-browser
node --test tools/api-policy-app.test.cjs
node tools/api-policy-browser-smoke.mjs --site "$PWD/out/api-policy-browser/site" --module "$PWD/examples/api-policy-revision" --out "$PWD/out/api-policy-browser/api-policy-smoke.json"
python3 -m http.server 8768 --bind 127.0.0.1 --directory out/api-policy-browser/site

http://127.0.0.1:8768/api-policy.html에서 같은 아홉 사실을 원본·읽기 전용 정책으로 계산하고, 두 판단의 열다섯 항목과 차이를 확인합니다. 저장 보고서는 파일을 불러온 다음 명시적으로 재계산해야 새 결과를 저장할 수 있습니다. 파일 입력은 원시 바이트를 그대로 전달하며, 편집기는 브라우저에 표시된 텍스트를 사용합니다. 각 Text의 UTF-8 65,536바이트 한도와 원본 디코더의 한도를 유지합니다. 이 서명 없는 과거·가상 비교는 사실의 진위나 현재 API 실행 권한을 인증하지 않습니다. 브라우저 비교는 기존 함수 입력 3,135개와 정밀도 경계 2개를 보존하고 색상 원본 비교 1,300개를 추가한 4,437건과 회전 원본 비교 2,472건을 합친 6,909건을 보존합니다. 시간 간격 두 함수에 각각 1,789건을 더한 10,487건도 유지하고, IsSpace 506건을 추가한 10,993건을 유지합니다. IsLetter 4,128건과 IsDigit 915건을 더한 현재 브라우저 원본 비교는 16,036건입니다. 잘못된 입력·채널 개수 등의 거부 420건은 별도 집계합니다. Node smoke 검사는 공유 입력 왕복 16,036건과 추가 호출 형태·타입 오류 63건도 검사하므로 총 거부 검사는 483건입니다. 아래 native 소비 예제는 브라우저 집계에 포함하지 않습니다. HTTP·rune·색상 검사는 유한 입력 관측이며 패키지 전체 호환성이나 성능을 보장하지 않습니다.

별도 crop-planner.html은 기본 모드에서 기존 crop 소비 프로그램을 crop/crop.wasm으로 실행합니다. Two-corner selection 모드는 별도 drag-crop/crop.wasm의 DragCropPlan을 실행하여 선택한 두 모서리만 정렬합니다. 좌표는 브라우저와 Wasm 사이에서 십진 문자열로 전달하므로 JavaScript의 안전한 정수 범위를 넘어도 원본 값을 보존합니다. crop/ 아래에 이 프로그램의 생성 Go, 실행·재실행 기록, 독립 Go 비교 입력과 빌드 메타데이터가 있으며 drag-crop/에도 같은 형식의 별도 증거가 있습니다. 두 모드는 각각 Go 기준값 88건, 잘못된 문자열 96건, JS 타입 104건, 인수 개수 10건을 검사합니다. 추가로 두 Wasm 프로그램을 함께 실행해 7개 입력의 14회 호출을 비교합니다. crop smoke 결과는 기존 16,036건 비교 및 483건 거부 집계와 분리합니다.

별도 언어 튜토리얼은 점수와 이름표를 받아 네 필드를 돌려주는 두 파일짜리 Gooo 프로그램을 실행합니다. 화면에서 입력을 바꾸고 원본 소스를 읽거나 내려받을 수 있습니다. 소스 변경은 native 실행 안내를 따릅니다. 정수는 int64 전체 범위를 보존하며 Text 입력과 반환 필드의 1,024 UTF-8 바이트 제한을 각각 검사합니다. 이 예제의 실행·재실행 기록과 브라우저 비교는 기존 Go 포트 호환성 집계에 포함하지 않습니다.

별도 UUID 파싱 화면은 기존 Google UUID ParseCanonical Gooo 코드를 변경 없이 WebAssembly로 실행합니다. 입력은 공백을 제거하거나 정규화하지 않은, 최대 1,024 UTF-8 바이트의 Text입니다. parsed, canonical_uuid, error, invalid_length를 성공·실패 모두 표시합니다. raw hex 파싱 오류의 반환 UUID가 정상 입력의 값과 같아도 parsed: false이면 실패입니다. 다운로드는 원본 UTF-16 입력과 실제로 전달한 Text를 담는 서명 없는 브라우저 관측이며, native 실행 영수증이나 보안 인증이 아닙니다. 이 화면의 유한 비교는 기존 16,036건 브라우저 함수 집계와 분리되며, 42개 포트나 native 소비 프로그램 수를 늘리지 않습니다.

브라우저 생성용 사례 261개도 기대 결과와 함께 native 실행·저장된 프로그램 재실행을 검증합니다. 입력 파일당 128개·32 KiB 제한을 지키도록 실제 JSON 바이트 크기로 나누며 사례를 생략하지 않습니다. 배포물의 evidence-index.json에 모든 배치 입력·실행·재실행 파일과 해시가 있습니다. execution.json·replay.json은 첫 배치의 원본 바이트 별칭이며 전체 기록은 인덱스를 따릅니다.

Full native port verification

This checks the port corpus and saved replay; it is separate from the small tutorial above.

The current full CI roster is 82 suites and 175,649 cases, with 2,305 batches under --case-profile uuid-and-literal-report-compact-v1. CI also selects --workspace-profile dependency-closure-v1 and --suite-order largest-corpus-first. The default local command below uses the legacy profiles and has different batch boundaries. The 66- and 68-suite counts below describe historical prefixes, not the current full roster.

Go 1.27.2, Git, POSIX shell이 필요합니다. go.mod를 인식하는 Go 설치는 필요한 도구 체인을 자동 선택할 수 있습니다. 저장소 루트에서 실행합니다.

./tools/bootstrap.sh
go run ./cmd/verify --out out/first

bootstrap은 고정한 컴파일러를 .compiler/에 받아 .gooo를 빌드합니다. 검증은 Go 도구 체인, 원본 소스 해시, 컴파일러 버전을 확인한 뒤 모든 입력을 실행하고, 저장된 프로그램을 다시 실행합니다. 결과는 out/first/summary.json, 각 함수·배치의 execution.json, replay.json, 입력 파일과 Gooo 소스에 남습니다. --out에는 기존에 없는 디렉터리를 지정합니다.

The verifier defaults to one suite at a time. --workers 2 runs up to two suites concurrently; the accepted range is 1–4. With the default legacy case profile, each suite keeps its original batch boundaries. All profiles retain execution, inspection, saved replay, and receipt-binding checks. The summary keeps corpus order and records the configured worker limit as native_suite_workers. --suite-order largest-corpus-first dispatches suites by descending case count, breaking ties by their original catalog index; the default is catalog. After a suite failure, pending work above the lowest failed catalog index is skipped and active higher-index work receives cancellation. Pending lower indices still run so the reported failure remains the earliest catalog failure, rather than whichever worker fails first; cancellation of the whole run still takes precedence. Every started worker is joined before return and private build cache cleanup. Full native CI uses three workers and retains every corpus and exhaustive check. See CI timing and suite order for the measured baseline, fixed-duration model and validation limits; this order is not a measured speedup claim.

--case-profile uuid-compact-v1 selects compact JSON case files for UUID Validate, the importing format Inspect, and ParseCanonical only. It keeps every original input, expected result and source workspace; other suites retain their original writer and boundaries. The sized bytes, including one final LF, are the same file hashed and passed to execution and saved replay. Each batch has at most 128 rows and 30,000 bytes. This profile requires the pinned compiler and a checked source-derived bound on its rewritten activity keys; it refuses an unsupported bound rather than changing the partition or execution path.

Full native CI selects --case-profile uuid-and-literal-report-compact-v1. This is the same UUID policy plus compact case JSON for app/literal-text-report:Report only. Index and Count, the Cut entries, and decimal/payload keep their existing writers and partitions. The new profile records its four entries, basis_profile: "uuid-compact-v1" and the exact bounds in the summary and timing header. Default legacy and explicit uuid-compact-v1 remain available with their original behavior.

The original 66-suite population retains 159,909 cases. Its historical legacy partition has 2,337 batches/2,471 timing records; the UUID-only profile has 2,109/2,243. The combined profile requires 2,063 batches for those same cases: UUID retains 195/197/239 and the literal Report uses 235 instead of 281. Appending the unchanged parser256/5 and payload101/4 gives the historical 68-suite prefix: 160,266 cases, 2,072 batches and 2,210 timing records. These source-partition counts are not an assertion that a new execution has completed. The current full roster requires fresh native execution, saved replay, all seven exhaustive checks and a complete timing footer for the corresponding source's CI. Within that historical 68-suite prefix, legacy requires 2,346 batches/2,484 records and UUID-only requires 2,118/2,256. No case profile reuses a previous successful receipt, and fewer batches alone do not establish a duration or memory improvement.

With --timing-out, each batch's existing batch_end record also carries command_resources.execute and .replay, identified in the header as gooo/native-command-resources/v1. The observer reads the completed command's existing OS wait accounting; it adds no process, wait, polling or receipt file. OBSERVED reports user/system CPU nanoseconds, raw MaxRSS with its OS unit, and normalized MaxRSS bytes. Linux reports raw KiB; Darwin reports bytes. NOT_AVAILABLE records a reason and null numeric fields when accounting cannot be read. NOT_OBSERVED means the command has not reported accounting, including a phase never reached after failure; it is not a zero resource measurement.

These values cover the waited CLI and only descendants included in its OS accounting. CPU is accumulated execution time, while MaxRSS is an OS high-water mark: neither represents a complete live process tree, CPU quota, simultaneous memory usage, or a memory limit. Do not sum MaxRSS across batches. The existing elapsed phases, corpus order, native results, saved replay and failure behavior remain required. No resource value authorizes an effect or proves a speedup. Without --timing-out, command resource accounting is not collected.

Bootstrap recovery

The current bootstrap stages downloads and builds before installing .compiler and replacing .gooo. A failed fetch, checkout, build, or identity check leaves the prior executable intact; correct the reported cause and rerun ./tools/bootstrap.sh. An installed compiler checkout must match the pinned revision and have no modified, untracked, or ignored files. Unrecognized paths are preserved and rejected with a diagnostic. An empty checkout left by the old bootstrap's failed first fetch is recovered after its original Git metadata is preserved under .compiler-interrupted.*/compiler.

Only one bootstrap can run at a time. Handled HUP, INT, and TERM signals clean up its temporary files and lock; a shell may wait for its child command to stop before running that cleanup. SIGKILL or a host crash cannot run cleanup. If .bootstrap.lock remains, check its pid and confirm that the bootstrap and its child commands have stopped. Inspect the directory, then move it aside to a new backup path before retrying. The script does not automatically delete an existing lock or unknown files. Do not move a lock while an install is running.

If the selected Go version differs, use export GOTOOLCHAIN=go1.27.2 in your shell before retrying. Bootstrap disables an enclosing Go workspace for its own commands. Its temporary-directory utility, mktemp, is supplied by macOS and Linux; the recovery regression suite additionally uses Python 3 in CI.

Run importing examples

실제 Gooo 앱은 상태 코드를 받아 {code, text, known}을 만듭니다.

mkdir -p out/demo
./.gooo package execute --json --inputs examples/inputs.json \
  gooo.workspace.json > out/demo/execution.json
./.gooo package replay --json --receipt out/demo/execution.json \
  --inputs examples/inputs.json gooo.workspace.json > out/demo/replay.json

예제 입력 404의 실제 결과는 다음과 같습니다.

{"code":404,"text":"Not Found","known":true}

입력만 주는 실행은 OBSERVED이며, 기대값을 비교한 검증 실행의 PASS와 구분합니다. 예제의 examples/inputs.json을 편집하면 다른 상태 코드도 실행할 수 있습니다. 새 모델이나 외부 추론 서비스가 필요하지 않습니다.

두 번째 앱은 바이트의 비트 길이, 1 개수, 반전 값을 레코드로 돌려줍니다.

mkdir -p out/demo
./.gooo package execute --json --inputs examples/byte-summary/inputs.json \
  byte-summary.workspace.json > out/demo/byte-summary.json
./.gooo package replay --json --receipt out/demo/byte-summary.json \
  --inputs examples/byte-summary/inputs.json byte-summary.workspace.json > out/demo/byte-replay.json

입력 170의 결과는 {"length":8,"ones":4,"reversed":85}입니다. 이 경로 역시 기대값 없는 입력 실행이며 위 원본 비교 검사와 별도로 사용할 수 있습니다.

세 번째 앱인 Unicode inspector는 기존 UTF-8·UTF-16 포트를 함께 사용해 코드 포인트와 서로게이트 쌍을 진단합니다. 유효한 U+FFFD 문자와 잘못된 입력쌍의 대체 결과를 구분하고, 정상 BMP 문자에서 EncodeRune이 반환하는 65533/65533을 잘못된 문자로 판정하지 않습니다. 실행 명령과 결과 필드는 예제 문서에 있습니다.

네 번째 앱인 색상 왕복 검사기는 RGB를 CMYK로 변환하고 다시 RGB로 복원해 채널별 차이와 일치 여부를 보여줍니다. 두 색상 포트를 Gooo에서 조합하며 원본의 전체 uint8 입력 범위를 유지합니다. 브라우저에서는 두 변환 함수를 각각 실행할 수 있고, 이 왕복 소비 앱은 native에서 실행합니다. 특정 색상 프로파일이나 프린터 보정은 수행하지 않습니다.

다섯 번째 앱인 바이트 회전 검사기는 바이트와 회전 수를 받아 회전 결과, 원상 복원 값과 전후 1비트 개수를 돌려줍니다. 최소 int64의 회전 수도 그대로 입력받으며, byte로 잘라내거나 원래 회전 수를 부호 반전하지 않습니다. 브라우저에서는 단일 회전 함수를 실행하고 입력·출력의 8비트를 비교할 수 있습니다.

여섯 번째 앱인 시간 간격 조정기는 나노초 단위의 시간 간격과 단위를 받아 반올림·절삭 결과, 반올림 변경량과 절삭 나머지를 반환합니다. 두 Go Duration 메서드의 전체 int64 입력 범위를 보존하고, 시계나 외부 서비스를 호출하지 않습니다. 브라우저에서는 각 함수를 별도로 실행하고 정확한 입력을 공유합니다.

일곱 번째 앱인 공백 검사기는 하나의 정수를 받아 Go rune 영역 여부, Unicode 스칼라 유효성, Go·ASCII 공백 여부, UTF-8 바이트 수와 UTF-16 코드 단위 수를 반환합니다. IsSpace와 기존 UTF 포트를 Gooo에서 조합합니다. 브라우저에는 단일 IsSpace 함수와 한 코드 포인트 붙여넣기 보조 입력을 제공합니다. 문자열을 잘라내거나 정규화하지 않으며 여러 코드 포인트를 하나로 간주하지 않습니다.

여덟 번째 앱인 식별자 문자 분류기는 문자·십진 숫자· 밑줄을 구분합니다. 아홉 번째 앱인 잘라내기 영역 계산기는 이미지 경계와 요청 사각형을 받아 교집합 좌표와 픽셀 존재 여부를 반환합니다. RectangleIntersect와 RectangleEmpty를 가져오며, 원점이 0이 아닌 이미지 경계도 그대로 처리합니다. 계산할 좌표를 반환하는 예제이며 이미지 파일을 읽거나 수정하지 않습니다.

열 번째 앱인 단순 대소문자 접기 비교는 두 rune의 다음 순환 멤버와 같은 접기 순환 여부를 반환합니다. 열한 번째 앱인 YCbCr 왕복 검사기는 RGB를 Y′CbCr로 변환한 뒤 복원 RGB·채널 차이·정확 일치 여부를 반환합니다. 두 앱 모두 native 실행과 저장 재실행을 제공합니다.

다른 Gooo 프로그램에서 가져오기

새 프로젝트에서 포트 사용하기는 고정 소스를 받고 포트·라이선스를 복사한 뒤, 아래 함수의 workspace·입력 파일을 만들어 실제 실행과 저장 재실행까지 진행하는 완전한 예제입니다. 새 앱은 이 저장소와 별도 디렉터리에 둡니다.

문자·십진 숫자 분류를 새 프로젝트에서 사용하기는 unicode.IsLetter·IsDigit를 조합하는 예제입니다. 필요한 두 소스 파일과 타입 선언, 원본 정수 입력의 범위 구분, 실행·저장 재실행을 고정 버전으로 따라 할 수 있습니다.

package checker
namespace checker
import utf8 "go/unicode/utf8"
entity Integer id "gooo://std/integer"
entity Boolean id "gooo://std/boolean"
activity Valid(Integer) -> Boolean id "gooo://example/checker/valid" computes `return utf8.ValidRune(input)`

원하는 포트 소스를 고정 Git 리비전에서 가져와 작업공간 안에 복사하고, 라이선스·NOTICE· upstream 기록과 원본 주석을 함께 보존합니다. 사용하는 작업공간 명세에 패키지 경로와 manifest 기준 상대 파일 경로를 등록합니다. import 자체가 패키지를 내려받지는 않습니다. 기본 실행 구성은 gooo.workspace.json, 실제 importing app은 response.gooo에 있습니다. 모든 검증 대상의 소스 목록은 verification-catalog.json에 있고, YCbCr 소비 앱은 별도 workspace로 실행합니다. 비트 연산을 가져오는 예제는 ByteSummary와 회전 수를 함께 받는 Byte rotation inspector입니다. 색상 변환 조합은 Color inspector와 color-inspector.workspace.json에 있습니다. 현재 배포 단위는 Gooo 소스와 workspace 명세이며 Go의 패키지 관리자와는 별개입니다.

검증 범위

기존 3,147건과 Unicode 소비 앱의 Go 원본 비교 334건·영역 밖 거부 12건을 그대로 유지합니다. 색상 포트는 원본 비교 1,300건·거부 56건, 색상 소비 앱은 원본 비교 637건·거부 24건을 추가합니다. 이 5,510건은 바뀌지 않습니다. 바이트 회전 포트는 원본 비교 2,472건·거부 36건, 회전 소비 앱은 원본 비교 672건· 거부 36건을 추가한 8,726건도 유지합니다. 시간 간격 두 포트의 원본 비교 3,578건, 소비 앱 1,789건을 더한 14,093건도 유지합니다. 공백 포트와 소비 앱은 각각 원본 비교 506건·int32 밖 확장 8건을 추가한 15,121건도 유지합니다. 문자·숫자 분류 두 포트는 원본 비교 5,043건·int32 밖 확장 24건, 식별자 문자 소비 앱은 원본 비교 4,570건·확장 12건을 추가한 24,770건도 유지합니다. 사각형 네 포트의 원본 비교 1,711건과 잘라내기 소비 앱 486건을 추가해, 기존 native 검사 26,967건도 유지합니다. SimpleFold는 원본 비교 3,505건과 int32 밖 identity 확장 11건, 두 rune 소비 앱은 원본 비교 497건과 영역 밖 거부 34건을 추가한 기존 31,014건도 유지합니다. YCbCr 두 포트는 원본 비교 2,160건과 영역 밖 거부 48건, 왕복 소비 앱은 원본 비교 924건과 거부 24건을 추가한 기존 34,170건을 유지합니다. Canon 371건과 드래그 선택 소비 활동 501건을 더한 기존 35,042건도 유지합니다. 여기까지가 표준 라이브러리 29개 포트이며, x/image 두 포트와 픽셀 경계 소비 예제의 별도 2,190건을 더한 기존 37,232건도 유지합니다. Unicode case mapping 네 포트의 원본 비교 16,208건·별도 확장 198건, 소비 앱의 원본 비교 3,602건·확장 11건을 더한 기존 57,251건도 유지합니다. 잘못된 case 선택자의 원본 비교 132건·확장 132건은 각각 위 포트 집계에 이미 포함됩니다. NRGBA 포트의 원본 비교 2,696건·영역 밖 거부 32건, 알파 합성 소비자의 원본 비교 2,158건·거부 104건을 더한 기존 62,241건은 그대로 유지합니다. 합성 기대값은 실제 Go draw.Draw의 NRGBA→RGBA 최적 경로와 일반 인터페이스 경로를 함께 확인합니다. 바이트 검색 포트와 소비 예제는 각각 문자열 6개와 전체 byte 256개의 원본 비교 1,536건과 needle 영역 밖 확장 16건을 추가합니다. native 검증 코퍼스는 기존 65,345건·54개 suite를 이룹니다. 기존 833개 배치 경계는 유지하며, 이 두 suite는 실제 직렬화 JSON 30,000바이트와 128행 상한을 함께 적용해 전체 882배치로 실행합니다. 범위는 유효한 UTF-8 Text 최대 1,024바이트이며 임의 Go 바이트 문자열 전체가 아닙니다. Google UUID Validate와 가져오기 예제는 각각 21,745건의 독립 원본 비교를 더합니다. 원본 9개 사례, 네 표기의 각 ASCII 위치 변경, 128개 URN 대소문자 조합, 0..1,024바이트 길이, Unicode·제어 문자와 접두 바이트 절단, 고정 표본을 포함합니다. 정확한 오류 문구와 길이 오류 분류까지 비교하는 이 단계의 합계는 108,835건·56개 suite입니다. 기존 54개 suite의 입력·소스 묶음과 882배치 경계를 유지하고 UUID 534배치를 추가합니다. JSON의 잘못된 UTF-8·단독 surrogate가 원래 바이트 그대로 거부되거나 보존된다는 뜻은 아닙니다. 원래 유효한 UTF-8 문자열로 오라클을 호출하며, 일반 Go byte string·전체 UUID 패키지는 범위 밖입니다.

별도 ParseCanonical Text 조합 API는 원본 Parse의 반환 UUID를 String()으로 표현하고, 오류 시 부분 값과 오류 상태를 함께 보존합니다. 기존 UUID 입력 21,745건에 추가 anchor 136개의 중복을 제거해 122건을 더한 21,867건을 비교합니다. 38바이트 외곽 문자, 실패한 hex 쌍의 부분 반환, hyphen 오류 우선순위, UTF-8 접두 인용, 길이와 byte 패턴을 포함하며 이 단계의 corpus 합계는 130,702건·57개 suite입니다. Go의 binary UUID 타입이나 임의 byte 입력 ParseBytes를 노출하는 API는 아닙니다.

새 RectangleIn과 FitsCrop는 각각 기존 사각형 이항 입력 486건과 추가 입력 84건을 합친 570건을 참조 코퍼스로 사용합니다. RectangleIn(requested, bounds)는 빈 요청에도 true를 반환하지만, 소비 앱은 !requested.Empty()를 먼저 요구하므로 빈·뒤집힌 요청을 false로 판정합니다. 네 경계의 초과, 포함·접촉·분리, 동일한 exclusive 최댓값, 빈 컨테이너와 int64·정밀도 경계를 다룹니다. 131,842건·59개 suite의 전체 native 비교가 일치했고 1,777개 배치의 저장재실행과 독립 raw receipt 감사를 확인했습니다. 실행 증거에 새 두 suite의 각 570건·18배치와 별도 거부 관찰을 기록합니다. 이미지나 GIF를 처리하는 기능은 아닙니다. 기존 57개 suite의 case-document 바이트·SHA와 1,741개 배치 경계는 유지합니다. 공유 geometry.gooo에 선언을 추가하여 소스 해시는 바뀝니다. 기존 활동의 ID·body를 보존하고 새 소스 식별자로 실행·저장재실행을 검사하며, 이전 receipt identity를 재사용하지 않습니다.

사각형의 네 좌표는 각각 전체 signed int64 범위를 받으며 영역 밖 확장 계약이 없습니다. 시간 간격은 두 입력의 전체 int64 범위를 받으며 영역 밖 확장 계약이 없습니다. 기존 영역 밖 거부 사례는 Go 동등성 집계가 아닙니다.

별도 go run ./cmd/check-unicode --out out/unicode-exhaustive는 실제 importing 프로그램의 수정하지 않은 생성 Go를 빌드해 0..U+10FFFF의 1,114,112개 입력에서 두 분류 함수를 2,228,224번 Go 원본과 비교하고 소비 레코드도 검사합니다. 이 수치는 위 native 영수증 집계에 합산하지 않습니다. signed int32 나머지 구간과 int32 밖 확장은 유한 경계 검사이며, signed int32 전체 전수 검사 또는 전체 Unicode 패키지 호환성을 주장하지 않습니다. 재생성 방법과 API 의미는 식별자 문자 예제에 있습니다.

cmd/verify는 SimpleFold의 검증된 실행·재실행에서 생성 Go를 한 바이트도 바꾸지 않고 별도 검사기로 빌드합니다. 0..U+10FFFF의 1,114,112개 입력을 원본 SimpleFold와 비교하며 결과를 simple-fold-exhaustive/와 요약의 simple_fold_exhaustive에 기록합니다. 이 검사는 위 유한 영수증 집계와 별개이고, 전체 int32 또는 모든 두-rune 쌍을 전수 검사했다는 뜻이 아닙니다. 정수 영역 밖 샘플도 따로 집계합니다.

case mapping 네 포트도 검증된 생성 Go를 수정 없이 실행합니다. To의 세 유효 case와 ToUpper·ToLower·ToTitle 각각에 대해 0..U+10FFFF를 비교한 총 6,684,672번의 관측은 case_mapping_exhaustive에 따로 기록합니다. 다른 int32 값·잘못된 case·int64 확장은 별도의 유한 비교이며, 소비 앱 전체 입력이나 모든 int32·case 선택자를 전수 검사한 것은 아닙니다.

YCbCr 두 변환도 검증된 실행·재실행의 생성 Go를 그대로 빌드해 각 16,777,216개 byte 3성분 입력을 Go 원본과 비교합니다. 총 33,554,432번의 비교는 위 영수증 사례 수와 따로 집계하며, 요약의 ycbcr_exhaustive와 각 ycbcr-exhaustive-* 폴더에 생성 소스 해시·도구체인·결과를 기록합니다. 소비 앱의 모든 RGB 왕복을 실행하거나 이미지 압축·색상 프로파일을 검증한 것으로 해석하지 않습니다.

다음 배치 수와 경계 보존 내역은 기본 legacy 프로필의 이전 포팅 단계를 설명합니다. 현재 CI의 uuid-and-literal-report-compact-v1은 UUID 경계와 literal Report의 compact 경계를 위 실행 안내처럼 별도로 계산합니다. 기존 uuid-compact-v1 수치는 해당 이전 프로필에만 적용됩니다. 이전 catalog는 Gooo 실행 입력 상한에 맞춰 총 1,777개 배치로 나눴습니다. 기존 833개 배치와 그 경계를 유지하며 IndexByte 21개·Search 소비 앱 28개 배치를 추가합니다. IndexByte·Search와 UUID의 세 suite는 128행 이하에서 실제 JSON 30,000바이트 상한에 맞춰 최대 접두 배치를 선택합니다. UUID Validate 257개·Inspect 277개 배치를 추가하며 이전 882배치의 경계는 바뀌지 않습니다. ParseCanonical을 추가했던 단계에서는 325개 배치를 더하고 기존 1,416개 배치의 입력·소스·경계를 유지했습니다. RectangleIn과 FitsCrop은 각각 18개 배치를 더하며 기존 1,741개 배치의 case JSON 바이트와 행 경계를 보존합니다. 공유 사각형 소스의 새 해시는 새 실행·저장재실행에 연결합니다. 기존 YCbCr까지의 465개 배치를 유지하고, Canon 6개·드래그 선택 소비 활동 16개, x/image Floor/Ceil 각각 14개와 픽셀 경계 소비 활동 16개 배치까지의 기존 531개를 보존합니다. case mapping 네 포트 131개와 새 소비 앱 57개 배치까지의 기존 719개를 보존합니다. NRGBA 포트 43개와 알파 합성 소비 앱 71개 배치를 추가합니다. case mapping 포트는 배치당 128건 이하, 소비 앱은 64건 이하입니다. Unicode 앱과 색상 포트는 64건 이하, 색상 소비 앱은 32건 이하입니다. 사각형의 단항 연산은 64건 이하, 이항 연산과 소비 앱은 32건 이하입니다. 새 레코드 기대값도 들여쓴 JSON과 마지막 개행을 포함해 32KiB 한도를 검사합니다. 원본 비교 기대값은 Gooo 구현과 별개인 Go 표준 함수 및 고정한 x/image 원본 메서드로 계산합니다. x/image 입력 영역 밖 false/0 레코드와 소비자 거부는 별도 계약으로 검사합니다. Unicode·색상·회전·공백 앱과 색상·회전·공백 포트의 영역 밖 기대값은 명시한 false/-1 계약으로 따로 검사합니다. 검증 도구는 결과뿐 아니라 입력 순서, 원본 기대값, 함수·입력 타입 식별자, 생성 코드 해시, 컴파일러·Go 버전, workspace·입력 파일 해시, 저장 재실행 연결을 검사합니다. 함수 식별자는 실행 기록 밖의 명시적 계약을 기준으로 선택한 패키지 선언, 생성 보고서, 각 실행 결과에 각각 대조합니다. 여러 입력은 전달된 타입 식별자도 검사하며, 타입 식별자가 없는 단일 입력 기록은 패키지 선언의 입력 타입과 연결합니다. 원본 파일의 내용과 패키지 소속은 실행 전에 읽은 소스에 대조하고, 생성 Go의 실제 내용도 기록된 해시와 비교합니다. 브라우저 빌드 검사도 독립적인 Dispatch 계약과 입력 타입·소스 연결을 확인합니다. 사각형 입력의 네 필드는 원래 정수 값과 필드 식별자·순서를 함께 비교합니다. python3 tools/check-rectangle-inputs.py out/rectangle-input-rejections는 양쪽 인수에서 누락·문자열·소수·int64 초과·null·추가 필드·중복 JSON 키의 거부 18건을 재현합니다. 이는 컴파일러 입력 검증이며 위 Go 원본 비교 수나 영역 밖 확장 수에 합산하지 않습니다. 새 tools/check-fits-crop.py는 문서의 14개 input-only 기록을 원래 int64 입력·Boolean 값· 소스/프로그램/producer와 저장재실행에 연결합니다. 이 기록의 판정은 OBSERVED이며 기대값을 공급하지 않은 입력에 correctness score를 만들지 않습니다. tools/check-fits-crop-inputs.py는 별도 90개 malformed 입력을 실제 CLI에 전달하도록 구성되어 있습니다. 반환된 진단·stage·counter만 보존하며, runtime 정보가 없다고 모델 호출이나 native 실행 횟수를 0으로 간주하지 않습니다. 이 거부 관찰도 위 원본 비교 수에 합산하지 않습니다. 검사 도중 소스가 바뀌어도 처음 읽은 동일한 소스 스냅샷을 모든 배치에 사용합니다. 고정 컴파일러는 한 생성 프로그램의 레코드 타입을 16개로 제한하므로, 검증기는 전체 소스 목록에서 공통 포트와 해당 배치의 소비 앱만 작업공간에 넣습니다. 실행에 포함된 소스의 식별자·해시도 이 선택된 목록에 정확히 대조합니다. 사례나 이식 함수의 입력 범위를 줄여 한도를 피하지 않습니다. 보고서·선언·실행 결과의 식별자를 함께 바꾸거나 입력 타입·소스 소속을 바꾼 기록을 거부하는 회귀 테스트도 포함합니다.

cmd/verify, cmd/build-demo, cmd/check-unicode의 영수증 검사는 각 JSON 객체에서 이스케이프를 해석한 키 이름이 두 번 나오면 거부합니다. 값이 같거나 배열 안의 객체에 중복이 있어도 거부하며, 서로 다른 객체가 같은 키를 쓰는 것은 허용합니다. 키의 대소문자 통합이나 Unicode 정규화는 하지 않고, 알 수 없는 유일한 필드에 대한 기존 정책과 정수 정밀도, 원본 영수증 바이트·해시 연결을 유지합니다. 정책 예제의 저장된 실패 영수증과 check-crop-example.py, check-rectangle-inputs.py의 영수증 읽기에도 중복 키 거부를 적용합니다. 위의 컴파일러 입력 거부 18건과는 별도 검사입니다. CI의 회전·시간 반올림·공백 관측 예제도 같은 Python 영수증 디코더를 사용합니다.

RuneStart와 math/bits의 기존 단일 입력 다섯 함수는 Go byte 영역을 전수 비교합니다. RotateLeft8의 전수 비교는 byte × 회전 수 0..7의 2,048쌍입니다. 원래 signed int64 회전 수 전체를 실행한 것은 아니며, 나머지는 음수·양 끝·큰 정수 경계와 고정 표본입니다. YCbCr 두 함수는 위 별도 검사에서 각 byte 3성분 영역을 전수 비교합니다. 그 밖의 함수는 모든 입력을 검사한 것이 아닙니다. 여러 함수가 같은 정수 입력을 재사용하므로 이 사례 수는 전역적으로 서로 다른 정수 값의 개수가 아닙니다. 별도 모델 학습, 성능 우위, 패키지 전체의 호환성은 검증 범위에 포함하지 않습니다. 첫 8개 함수의 관측, 13개 함수의 관측, Unicode 소비 앱 추가 관측, 색상 포트·소비 앱 추가 관측, 바이트 회전 포트·소비 앱 추가 관측, 시간 간격 포트·소비 앱 추가 관측, 공백 포트·소비 앱 추가 관측, 사각형 포트·소비 앱 추가 관측, YCbCr 포트·소비 앱과 전수 비교 관측, 릴리스별 실행·재실행 기록을 참고하세요. 릴리스 기록은 해당 버전에 고정되어 있으며, 이후 변경의 기록은 각 GitHub Actions 실행에서 확인할 수 있습니다.

언어 개발로 돌려주는 자료

./tools/probe.sh --out out/probes

반복문·바이트 인덱싱·비트 연산의 작은 Gooo 예제는 선언 검사를 통과하지만 본문 생성 결과는 서로 다릅니다. 현재 고정 컴파일러에서 조건만 사용하는 loop.gooo는 지원되는 카운터 반복 형식이 아니므로 거부되고, bitwise.gooo는 & 연산자 때문에 거부됩니다. 반면 byte-index.gooo는 생성에 성공하지만 비어 있지 않은 Text를 전제로 하는 input[0] 접근을 그대로 보존합니다. 따라서 생성 성공만으로 인덱스 안전성이나 실행 정확성이 입증되는 것은 아닙니다.

현재 generation boundary 표는 이 세 fixture의 선언 검사·본문 생성 결과와 진단을 함께 기록합니다. 스크립트는 모든 fixture가 실패한다고 가정하지 않고 이 기대 결과를 검사하며, 컴파일러 지원이 바뀌면 조용히 지나가지 않고 검사가 실패하도록 합니다.

• 언어 분석: 실제 지원 범위, API 변환과 제약

• 다음 이식 로드맵: 문자열 순회, hex, google/uuid의 선행 조건

• 기여 방법: 원본 추적과 동작 비교를 포함한 이식 절차

• 경계 재현: 컴파일러 개선에 사용할 최소 예제

• 바이트 입력 조건 실험: 개발 컴파일러에서 같은 최종 출력과 다른 내부 조건을 구분한 재현 자료. 이 실험 자체는 기본 컴파일러 핀이나 포트 수를 늘리지 않습니다.

Literal Text 검색 보고서

검색 보고서는 진단 문자열과 literal phrase를 받아 두 원본 입력, 첫 byte offset·존재 여부·겹치지 않는 개수·두 UTF-8 byte 길이를 JSON으로 돌려줍니다. 빈 phrase의 Count는 code point 수+1이며 grapheme 수가 아닙니다. 대소문자·정규화 차이를 유지하고, 각 입력은 decoded valid UTF-8 Text 1,024바이트 이내입니다.

새 세 suite는 같은 고유 입력 9,313쌍씩을 독립 Go 원본과 비교하도록 작성됐습니다. 85×85 짧은 문자열, 0..1,023의 모든 byte 위치, 두 인수의 길이 경계, NUL·Unicode·직렬화· 비중첩 사례와 고정 PCG 표본을 포함합니다. 실제 JSON+LF의 30,000바이트·128행 상한으로 Index 137, Count 137, Report 281 배치를 유도했습니다. 기존 main445의 59개 suite·131,842건·1,777개 배치의 입력·소스·manifest·배치 파일을 보존하며, 확장된 작성 코퍼스는 159,781건·62개 suite·2,332개 배치입니다. 이 소스 기반 수치는 필수 유한 검증 범위를 지정합니다. 완료된 실행 결과는 해당 소스의 CI/native 보고서에서 확인합니다.

전체 finite verifier는 기존 원본 입력·소스·producer·Go 출력과 저장 영수증의 바깥 SHA 결합을 검사합니다. 이 경로의 inner prior_result_sha256·전체 generation provenance·typed-plan 결합은 NOT_CHECKED입니다. 별도 필수 input-only 24쌍 Report 검사는 독립 검토된 고정 profile에서 그 세 결합까지 검사합니다. 그 profile을 finite --cases에 재사용하지 않습니다. input-only native 영수증은 OBSERVED·finite_total=0을 유지하며 Go oracle 검사는 별도입니다.

별도 마지막 표식 보고서는 strings.LastIndex를 추가한 버전1의8필드 진입점입니다. 겹친 일치도 마지막 위치에 포함하므로 aaaaa/aa는 첫 위치0·마지막 위치3·비중첩 개수2를 반환합니다. 기존7필드 Report의 소스·입력·진입점은 유지하며, 새 두 suite의1,783건을 별도로 검사합니다. 기본 예제26쌍은 실제 실행과 저장 replay로 다시 확인할 수 있습니다.

Literal Cut 분할 보고서

Literal Cut 보고서는 같은 문자열과 needle로 Cut, CutPrefix, CutSuffix를 호출하고 원래 두 입력, 세 결과와 두 byte 길이를 11개 필드로 반환합니다. 예를 들어 one::two::three와 ::의 Cut은 첫 구분자만 나눠 one과 two::three를 반환합니다. 접두·접미 함수는 해당 가장자리만 제거하며, 빈 needle은 성공입니다. 공백·NUL·CRLF·BOM과 조합형/완성형 Unicode를 정규화하지 않습니다.

입력은 각각 decoded valid UTF-8 Text 1,024바이트 이내로 한정합니다. Go의 여러 반환값은 required-field record로 옮겼으며, 임의의 byte 문자열·더 긴 입력·전체 strings 패키지 호환은 제공하지 않습니다. 새 네 suite는 고정된 수동 입력 32쌍을 독립 Go 원본으로 각각 다시 계산합니다. 기존 62개 suite·159,781건·2,332개 batch의 factory, 원래 Gooo 소스, workspace와 batch 경계를 보존하고 네 suite를 뒤에 추가합니다. 실제 JSON+LF 배치 분할 검증에서 Cut·CutPrefix·CutSuffix는 각 1개, Report는 2개 배치로 계산됐습니다. 필수 통합 범위는 기본 legacy에서는 66개 suite·159,909건·2,337개 배치이며 계측 완료 기록 수는 2,471개입니다. 이전 uuid-compact-v1은 같은66개 suite·입력·기대값을 2,109개 배치·2,243개 계측 기록으로 나눕니다. 현재 uuid-and-literal-report-compact-v1의 해당66개는 2,063개 배치·2,197개 계측 기록을 요구합니다. literal Report만281→235배치이며 Cut 네 suite와 Index·Count 경계는 그대로입니다. 십진수·payload 두 suite까지 포함한 현재68개 요구 범위는 위 실행 안내의2,072배치·2,210기록입니다. 이 분할 검사는 새 public entry의 전체 native 실행·저장 replay 완료를 대신하지 않습니다. 완료된 실행과 유한 검증 범위는 해당 소스의 CI/native 보고서에서 확인합니다. 기존 브라우저 프로그램과 검증 범위는 확장하지 않습니다.

원본과 라이선스

upstream.json에 Go 1.27.2의 커밋 022c8636110ebac86a9b88724cda168ed713c21f, 파일 SHA-256, Gooo 0.6.32-dev 컴파일러 커밋 83928fa4538245abe33b08549da47f8cbdc50ed2을 고정했습니다. 테스트의 Go 도구 체인에서도 원본 파일 해시가 일치해야 합니다.

기존 Go 이식 부분은 BSD 3-Clause 라이선스입니다. Go 원본 저작권과 원본 라이선스, NOTICE를 보존합니다. 별도 CEL 규칙과 예제에는 Apache-2.0 조건을 보존하며, CEL 포트 출처와 예제 라이선스에 Google codelab 원본과 수정 범위를 명시합니다. 기존 Gooo standard library의 기초 숫자·논리·문자열 함수와 함께 사용할 수 있도록 별도 패키지 경로를 사용합니다.

x/image 고정소수점 경계 → 픽셀 사각형

작은 native 예제는 raw Q26.6 좌표를 Floor/Ceil로 바꾸고 기존 RectangleIntersect로 잘라냅니다. 기존 35,042건은 그대로 유지하며 포트 참조 1,664건·영역 밖 거부 16건, 소비자 참조 471건·raw 영역 거부 33건·Ceil overflow 거부 6건을 더합니다. 이 단계까지의 finite 코퍼스 37,232건·45개 suite, 31개 포트는 보존됩니다. 픽셀 경계는 12번째 소비 예제이며, 이후 case mapping 네 포트와 13번째 소비 예제까지의 총계는 35개 포트·15개 소비 활동입니다. 이후 NRGBA 변환과 알파 합성 예제까지의 36개 포트·14개 소비 프로그램·16개 소비 활동은 유지하며, 바이트 검색까지의 37개 포트·15개 소비 프로그램·17개 소비 활동을 유지합니다. Google UUID Validate와 importing inspector까지의 38개 포트·16개 소비 프로그램·18개 소비 활동을 유지합니다. 별도 ParseCanonical Text API까지의 39개 포트·16개 소비 프로그램·18개 소비 활동을 유지합니다. RectangleIn과 FitsCrop까지의 총계 40개 포트·17개 소비 프로그램·19개 소비 활동을 보존합니다. 새 Index·Count와 Literal Text Report를 포함한 소스 목록은 42개 포트·18개 소비 프로그램·20개 소비 활동입니다. 이 목록을 보존하고 Cut·CutPrefix·CutSuffix와 Literal Cut Report를 덧붙인 작성 소스는 45개 포트·19개 소비 프로그램·21개 소비 활동입니다. 신규 네 suite는 각 원래 입력 32쌍을 사용하며, 완료된 native 실행과 replay는 해당 소스의 CI 보고서로 구분합니다. 그 목록과 별도로 path.Ext·path.IsAbs, IPv4 분류 함수 6개와 각각의 importing Report를 더한 단계의 작성 소스는 53개 포트·21개 소비 프로그램·23개 소비 활동입니다. 그 단계의 catalog는 66개 suite·159,909건·7개 전수 검사를 유지했고, UUID-only compact profile에서는 2,109개 배치였습니다. Path Facts의 generated-native 출력 29,523개 및 CLI·replay 각 72개와, IPv4 Address Facts의 CLI·replay 각 352개 및 생성 리포트 입력 202개는 따로 집계합니다. 각 입력 범위와 검사 방식을 확인하세요. 전체 라이브러리 호환성·네트워크 접근 안전성·성능 향상을 입증하는 수치는 아닙니다. 새 prefix query 두 포트와 importing probe·rule-pair 구성을 더한 작성 소스는 55개 포트·23개 소비 프로그램·26개 소비 활동입니다. 별도 검사기는 현재 소스로 54개 CLI 실행·54개 저장 영수증 재현과 112개 생성 함수 결과를 독립적인 Go 계산과 비교합니다. 입력 존재나 이전 기록을 새 native 성공으로 계산하지 않습니다. 원본 int32 전체의 동작을 구현하되 2^32 전수 검사를 주장하지 않습니다. 브라우저 21함수와 두 crop 모드는 그대로입니다.

The bounded Agent Mesh adaptation separately retains its original Apache 2.0 license and source attribution in the port notice and the example notice.

십진수 파서와 Payload Admission Facts를 더한 현재 작성 소스는 56개 포트·24개 소비 프로그램·27개 소비 활동입니다. 새 일반 native suite 두 개는 parser 256개와 policy 101개 입력을 추가하여 68개 suite·160,266개 case를 요구합니다. 기존 66개 suite의 입력·기대값·workspace는 보존하며 현재 소스 분할 검사는 새 9개 배치(parser 5·policy 4)를 추가하여 UUID와 Literal Report를 함께 압축하는 현재 CI profile에서 2,072개 배치·2,210개 계측 기록을 요구합니다. UUID-only compact profile은 2,118개 배치·2,256개 기록, legacy는 2,346개 배치·2,484개 기록을 유지합니다. 이는 분할 관측이며 현재 소스의 native·저장 replay 완료는 별도로 필요합니다. 입력 파일 생성이나 이전 receipt를 새 native 실행 성공으로 계산하지 않습니다. 이 순수 정책은 원본 7개 관찰과 14개 판단 필드를 제공하지만 실제 HTTP framing·권한·호스트 사실의 진위·quota나 효과를 보장하지 않습니다.