Spring Capability Coverage Map

Spice aims to cover as much of the practical Spring Boot and Spring Modulith platform as provides value to Go developers. This is a living product map, not a promise to port Java classes verbatim.

Maturity and evidence

The status column records implementation disposition, not release maturity: available means a Spice-owned implementation and repository acceptance path exist, integration means an opt-in adapter or deliberately bounded Go-native alternative exists, and not-planned records an explicit non-goal. Spice is still pre-alpha, so every capability in this table remains experimental as a support commitment until the first signed preview. Package-level compatibility intent is recorded separately in api-compatibility.md.

References to container, server, browser, or installed-IDE tests describe test assets owned by the relevant Spice ecosystem repository. They do not imply a mandatory cross-platform release gate unless the repository migration ledger marks that gate complete. The standalone packaged installed-GoLand suite proves real gutter Run and a native Go/Delve breakpoint against Petclinic on the mandatory Windows/Linux UI lanes; the coordinated real-service matrix remains outstanding.

Area	Spring capability	Spice direction	Status
Core	Application bootstrap and lifecycle	Exact roots/hooks/cleanup, immutable IR, generated construction/start/stop/run plus command bootstrap, rollback, idempotency, stable exit codes, process-boundary signals, and caller-owned low-level context policy; spice run safely regenerates, builds a unique trimpath package-main candidate, relays Windows/Unix termination, and preserves application exit status	available
Core	Dependency injection	Exact concrete factories plus constructible @Component/@Configuration/@Service/@Controller/@Repository stereotypes and configuration-owned @Bean methods, deterministic constructor discovery, explicit typed @Implements interface candidates resolved from any namespace-imported package in the loaded Go module graph, compiler-owned mirrored source-unit assertions and exact pointer/value/generic method-set checks, a compiler-owned named runtime-interface catalog shared with LSP authoring, names/aliases, qualifiers, primary/fallback/name selection, ordered slice/map collections, typed optional/lazy/provider handles, explicit singleton/prototype/request/session cleanup ownership, deterministic diagnostics, a typed generated singleton Components snapshot, and direct-call generated Go without reflection, an IDE-index dependency, or a runtime locator	available
Core	Auto-configuration	@Application provides safe generated command conventions; explicit typed @management.Enable, @observability.Logging, and @otel.Enable companions plus blank-imported .../autoconfigure library defaults are compile-time validated, carried in immutable IR, conditionally pruned before construction, and deterministically composed. This is Spice’s Go-native contract: typed annotations, factory references, and explicit imports replace hidden dependency-presence and classpath conditions, while profiles and typed configuration remain explicit application inputs	available
Core	Starters and dependency alignment	Explicit blank imports of dedicated .../autoconfigure packages select statically decoded typed factory references from the shared typed program; application exact-output beans replace sole defaults, matching names replace one repeated collection default, distinct beans extend collections, unavailable dependencies cause deterministic backoff, spice beans --explain exposes selection and Go module/replacement/review provenance, and generated code uses direct calls with cleanup/rollback and no init, runtime scan, dependency-presence activation, or Spice sidecar resolver; reviewed PostgreSQL, MySQL, Redis, SMTP, OIDC, OAuth2-client, gRPC, WebSocket, OpenTelemetry, and Kafka integrations are independently versioned modules and remain explicit opt-ins	available
Core	Resources	Instance-owned immutable loaders resolve canonical spice://mount/path locations over explicit caller-owned fs.FS mounts with rooted path validation, cancellation, bounded reads, stable metadata, no global registry, and no hidden network access	available
Core	Validation, data binding, type conversion, and formatting	Layer-neutral typed validators compose immutable rejected-value-free violations with deterministic order and cancellation; reflection-free typed converters/codecs provide custom composition plus safe Boolean/integer/float/duration/time/URL representations shared by configuration and HTTP binding; generated binders replace mutable JavaBean property reflection	available
Core	Environment, context events, and internationalization	Explicit ordered property/profile sources, typed generated configuration, generated typed application events, module-aware observations, and immutable bounded locale catalogs provide the practical context capabilities without global environment, event bus, or locale state	available
Core	Expression language	A bounded typed Boolean/string language evaluates only explicit positional variables/functions with deterministic parsing, cancellation, and no reflection, property traversal, bean lookup, assignment, allocation, I/O, or ambient state; @security.Authorize(expression=...) is compiler-validated against exact principal symbols and reuses that schema in immutable runtime policies, while broader application logic remains typed Go	integration
Core	AOP, proxies, and load-time weaving	Generic typed invocation chains plus generated per-route request/response interceptor fields wrap direct controller, transaction, and cache calls with ordinary debugger frames; security, observations, HTTP middleware, lifecycle, retry, and events retain purpose-built generated/typed decorators. Universal runtime pointcuts, subclass proxies, self-invocation interception, AspectJ weaving, and class-loader hooks are deliberately excluded	integration
Core	Resilience and null safety	Explicit finite retry/cancellation/exhaustion contracts, typed optionals, exact interface checks, compile-time diagnostics, NilAway, vet, and panic-safe asynchronous/event boundaries replace implicit proxy retries and Java nullability metadata	available
Core	Data buffers and codecs	Standard io ownership plus bounded JSON, resource, MIME, HTTP, WebSocket, gRPC, and configuration codecs cover application boundaries; a universal reference-counted pooled-buffer abstraction remains deliberately outside the core until a measured Go use case requires it	integration
Core	Ahead-of-time processing	The single typed-program compiler emits deterministic, inspectable, trimpath ordinary Go with direct calls, generated ownership/source maps, no runtime scanner or reflection container, and no compiler dependency at application runtime	available
Core	Runtime BeanFactory mutation and bean-definition inheritance	Import-selected auto-configuration supplies compile-time typed fallback factories; generated named BeanOverrideLayer values compose immutable parent-to-child overrides with deterministic later-layer precedence before application construction. Running-graph mutation remains deliberately unsupported so exact Go identity, cleanup, rollback, and deterministic startup are preserved	integration
Configuration	External properties and profiles	@ConfigurationProperties typed/module-owned declarations become exact provider nodes with deterministic generated schema/binders; constructible @Configuration types own direct-call @Bean factory methods; explicit rooted JSON/profile and environment sources provide precedence, provenance, validation, redaction, and caller-owned loading	available
Web	MVC/REST controllers	Exact provider-owned controller/route IR plus deterministic generated typed/raw net/http adapters, ordered middleware, and panic-safe ServeMux registration	available
Web	Request binding and validation	Generated path/query/header/body/form DTO binding uses strict bounded JSON or URL-encoded decoding, safe scalar conversion, immutable rejected-value-free BindingResult, and exact compile-time validated post-bind request validation	available
Web	Error handling and content negotiation	Generated adapters apply RFC 9457 secure error mapping, JSON/HTML negotiation, explicit 204 responses, closed render/303 outcomes, and caller-selected error policy; view routes can atomically render a safe shared HTML problem model and fall back to JSON when rendering is canceled or fails	available
Web	OpenAPI and REST documentation	Deterministic manifest-owned OpenAPI 3.1 contracts cover typed parameters, JSON and URL-encoded bodies, JSON/HTML/303 success outcomes, problem responses, raw-route limits, and module ownership	available
Web	HTTP clients	Base-scoped context-owned net/http clients provide safe defaults, redirect/SSRF boundaries, bounded typed JSON, RFC 9457 remote errors, and a raw escape hatch	available
Web	Sessions	Typed stateless sessions provide AES-256-GCM confidentiality/integrity, bounded key rotation, embedded expiry, strict JSON and cookie limits, secure host-only defaults, prefix enforcement, explicit local-insecure opt-in, and concurrent-use/fuzz verification; server-side revocation stores remain explicit integrations	integration
Web	Server-side templates	Caller-owned fs.FS sources compile deterministically through contextual html/template escaping with strict missing keys, bounded source/output, duplicate-definition rejection, cancellation, immutable concurrent execution, and response writes only after complete successful rendering; generated view routes require one exact renderer bean and call it directly for closed render/303 outcomes	available
Web	Internationalization	Immutable bounded UTF-8 properties catalogs provide deterministic locale discovery, quality-aware Accept-Language selection, regional-to-language matching, default-key fallback, and explicit DI; Petclinic proves English, German, and Spanish layouts and localized browser errors without a global locale	available
Web	WebSocket, GraphQL, gRPC	The independently versioned spice-framework/starter-grpc module provides explicit generated-protobuf service registration, TLS-by-default server/client ownership, bounded messages/concurrency, standard health, graceful cancellation-aware drain, and payload-free unary/stream observations, with real local TLS/mTLS acceptance and no second IDL or generator; spice-framework/starter-websocket provides authenticated TLS/same-origin defaults, bounded upgrades/messages/connections/close, explicit subprotocol/compression policy, context-owned client/server sessions, and payload-free observations with real local TLS acceptance; GraphQL and generated application composition remain follow-up integration work	integration
Security	Authentication and authorization	Immutable verified principals, source-validated @security.Authorize route policies, deterministic generated deny-by-default 401/403 guards, OpenAPI policy metadata, direct-service authorization, and bounded observations are available; commerce proves caller middleware authentication plus allowed, unauthenticated, and insufficient-scope generated route decisions, while production authentication remains an explicit OAuth2/OIDC starter integration	integration
Security	Resource server and client	The independently versioned spice-framework/starter-oidc module verifies JWT signature, exact issuer/audience, expiry, strict bearer syntax, and bounded role/scope claims; required and optional bearer middleware compose with generated route guards without downgrading invalid credentials. spice-framework/starter-oauth2client supplies HTTPS-only bounded client-credentials HTTP clients with separate caller-owned token/resource transports. Opaque-token introspection and delegated-user flows remain separate opt-in ecosystem integrations	integration
Data	JDBC and transaction management	Standard-library executor and transaction manager contracts provide caller-owned pools, module/boundary metadata, commit/rollback ownership, joined failures, panic rollback, explicit callback-context executor access, and observations; @data.Transactional compiles for typed HTTP routes and interface-bound service decorators; commerce proves serializable placement, lifecycle-ordered migration, persisted lookup, and an integration-tagged PostgreSQL close/reopen path. Additional drivers remain explicit integrations	integration
Data	Repository abstractions	Immutable reflection-free query definitions provide typed decoders, exact single-row cardinality, bounded ordered lists, transaction-compatible executors, and safe errors; compiler-owned repository assertions in mirrored source units prove exact interfaces without polluting handwritten files; commerce and Petclinic inject explicit repository interfaces and execute ordinary direct SQL through generated transaction/read executors. Spice deliberately uses typed Go methods rather than parsing repository method names	available
Data	JPA/Hibernate	Transparent persistence contexts, runtime entity proxies, lazy-loading interception, dirty tracking, and Java annotation reflection are deliberately not planned. Spice uses explicit aggregate types, repository interfaces, generated compile-time assertions, typed SQL decoders, and caller-visible transaction ownership so ordinary Go debugging and cancellation remain truthful	not-planned
Data	PostgreSQL, MySQL, Redis, MongoDB, Elasticsearch, Cassandra, Neo4j	Independently versioned reviewed PostgreSQL, MySQL, and Redis starters keep all three external client graphs out of core: PostgreSQL provides secure pools plus real-container transaction, query, advisory-lock, migration, outbox, and restartable-batch verification; MySQL provides verified-TLS pool ownership without global configuration, and Petclinic proves advisory-locked resumable InnoDB schema/data migration plus aggregate transactions against MySQL 8.4; Redis provides secure bounded client ownership and a typed JSON cache.Store with real-server expiration/cancellation verification. Other curated clients remain separate opt-in integrations	integration
Migration	Flyway/Liquibase	Module-owned immutable plans provide global version ordering, normalized SHA-256 drift detection, exact registry-prefix reconciliation, and cancellation; the PostgreSQL backend pins a session lock, atomically commits multi-statement scripts with registry metadata, supports the full uint64 version domain, and discards connections after uncertain unlock; Petclinic’s MySQL profile uses an explicit advisory lock and checksum-verified idempotent steps to provide honest crash-resumable behavior because MySQL DDL implicitly commits	integration
Messaging	Kafka, RabbitMQ, JMS-like APIs, Pulsar	Immutable bounded transport-neutral messages, explicit publishers/handlers, and race-safe single-settlement deliveries define the starter boundary with caller-owned cancellation and no connection-by-presence behavior; the independently versioned spice-framework/starter-kafka module provides verified-TLS/authenticated defaults, all-ISR synchronous idempotent publication, bounded sequential consumer groups with explicit commit/retry/reject behavior, lifecycle ownership, and payload-free observations. Real authenticated Redpanda acceptance proves delivery, commit/restart, cancellation, and cleanup through the explicit local plaintext mode; live TLS broker acceptance, generated listeners, dead-letter routing, RabbitMQ, and deployment-specific failure topology remain target-owned integration work	integration
Messaging	Email	Immutable transport-neutral messages provide caller-owned identity/time, stable To/Cc/Bcc envelopes, Bcc-safe deterministic MIME, text/HTML alternatives, bounded attachments, injection rejection, and defensive copies; the instance-owned test sender adds bounded immutable attempts, deterministic failures, explicit overflow, decoded inspection, cancellation, concurrency safety, and payload-free observations; the independently versioned spice-framework/starter-smtp module requires verified STARTTLS or implicit TLS, authenticates only after TLS, owns per-attempt connections/timeouts, conservatively retries transient pre-DATA failures, never replays ambiguous post-DATA failures, and emits payload-free observations; commerce consumes that immutable module, explicitly binds its concrete delivery to mail.Sender, composes a deterministic attached receipt after transaction commit, defaults to inspectable zero-network delivery, and selects SMTP through typed secret-redacted configuration	integration
Events	Application events	Immutable generic topics provide exact payload types and deterministic in-process delivery; @event.Topic/@event.Listener declarations compile into module-aware listener metadata and a synthetic exact publisher graph rendered as direct listener-bound topic construction with caller-owned observers and rollback; bounded transactional messages, a driver-neutral SQL store, atomic enqueue/lease contracts, and at-least-once dispatch are also available	available
Scheduling	Scheduled and asynchronous work	Compile-time @schedule.FixedDelay generates exact non-overlapping provider-owned jobs; @async.Execute generates readiness-gated typed application submit methods backed by one configured bounded executor with backpressure, direct provider calls, caller-owned lifetime/observers, panic containment, deterministic failure joining, graceful drain before provider cleanup, and bounded snapshots; the commerce reference exercises both paths	available
Batch	Batch jobs	Immutable module-owned ordered jobs, atomic attempt/checkpoint/failure contracts, exact completed-prefix restart validation, fresh bounded failure transitions, panic containment, safe observations, a concurrency-safe bounded in-process store, and a driver-neutral lease-aware SQL persistence protocol are available; the opt-in PostgreSQL backend supplies migration-owned schema plus atomic statements verified for restart, concurrency, drift, lease takeover, and stale-owner rejection against a real server	integration
Cache	Cache abstraction	Generic stores and a bounded concurrent LRU/TTL implementation provide explicit expiration, caller-owned time, key-free observations, and aggregate metrics; @cache.Cacheable typed GET and interface-bound service declarations compile into fail-closed module-aware exact key/value metadata, configured bounded store construction, and direct hit/miss logic; the opt-in Redis starter supplies bounded namespaced typed JSON storage with the same contract	available
Resilience	Retry	Explicit finite policies and generated @retry.Retryable service decorators provide opt-in error classification, a conservative transient default, capped deterministic backoff, context cancellation, typed exhaustion, testable waiting, and attempt observations	available
Observability	Actuator endpoints	Explicit @Enable allowlists deterministically generate exactly selected health/liveness/readiness/info/metrics/configprops/modules routes, lifecycle-state probes, bounded route metrics, schema-backed configuration provenance with mandatory secret redaction, and a runtime spice.modules/v1 canvas without package scanning; compile-time public or direct-peer loopback access rejects forged proxy provenance	available
Observability	Structured logging	Explicit @observability.Logging composition installs instance-owned log/slog adapters with safe compiler-owned route/module and lifecycle metadata; @observability.Observed adds generated instance-owned service-method duration/failure/panic boundaries without global logger state	available
Observability	Metrics and tracing	Generated module-aware observations and bounded in-process metrics remain core contracts; the independently versioned spice-framework/starter-otel module provides explicitly selected @otel.Enable OpenTelemetry v1.44 HTTP traces/metrics with exact observer-role validation plus payload-free typed event delivery spans/metrics using compiler-owned publisher/subscriber module identities; applications own providers and exporters	integration
Testing	Application context and test slices	spice test --module validates and executes exact focused Modulith package graphs with ordinary Go race/count/run/timeout controls; generated BeanOverrides plus bean.Replace/ReplaceFactory provide exact-type singleton replacement through the normal dependency, rollback, module-cleanup, and shutdown path without reflection or strings; generic spicetest.NewContext preserves the concrete generated application and typed Components API while owning optional startup, bounded cleanup, failure rollback, and concurrent close; spicetest.NewHTTP constructs real generated applications behind loopback-only bounded HTTP with strict JSON/problem decoding, construction rollback, and idempotent lifecycle cleanup; generic spicetest.NewSQL subjects receive only a transaction executor and always roll back; public-only annotation/sdk/sdktest validates third-party descriptors, handlers, diagnostics, cancellation, and determinism, with the HTTP path exercised by commerce and SQL rollback verified against PostgreSQL	available
Development	Devtools and reload	spice dev recursively content-polls relevant workspace files on Windows/Linux, deterministically debounces with a maximum delay, cancels obsolete preparation, applies guarded generation, builds unique candidates, retains the last-known-good process on analysis/build failures, and performs bounded process-group restart. The standalone Petclinic repository’s black-box test starts its generated multi-package application through the authorized go tool, introduces an invalid annotation, proves revision 1 remains live, fixes the source, observes the first successful revision at or above 3 and its matching graceful restart, verifies canonical generated Go and physical source preservation, terminates the complete process tree on Windows/Unix, and rejects every former naked-annotation/gocommand-* failure; native notification acceleration remains planned above the polling correctness fallback	integration
Development	Editor tooling	The editor-neutral spice lsp uses the shared overlay compiler service for versioned diagnostics, alias-aware @import and annotation completion, bounded offline pre-import descriptor discovery across the target module graph/workspace/replacements/vendor/cache with package-version-tool authorization detail, rich descriptor hover and signature help, real descriptor definition/document-link and handler implementation navigation, safe source fixes, and a confirmed two-step annotation-tool install action that runs the exact go get -tool against a temporary modfile, displays the complete bounded go.mod/go.sum diff without mutation, then applies only after both original hashes match. The retired @spice.import spelling receives an exact replacement. The independently versioned primary GoLand plugin creates canonical valid-Go // @ source, provides zero-width prefix concealment, theme-owned token colors, exact PSI references, modifier-hover/click navigation, documentation, provenance, and offline presentation. Its packaged-plugin UI suite verifies physical-source preservation, reclaimed width, light/dark rendering, navigation, documentation, and health against the real standalone Petclinic module; it also clicks the installed gutter Run action, captures the complete-package spice run command/startup, stops it cleanly, sets a physical-source breakpoint, launches the native Go/Delve debugger after guarded generation, and requires an actual suspended main.main frame on Windows and Linux without a gocommand-* fragment. Schema-5 manifests and the read-only spice generated text/JSON command provide deterministic source/generated navigation for IDE and debugger clients. The supported secondary Zed adapter launches the same server beside gopls within its documented no-concealment boundary	integration
Modulith	Module discovery	Import-path roots, longest-root package ownership, root APIs, named interfaces, and unassigned-package metadata	available
Modulith	Module dependency verification	Real Go import edges, explicit allowed APIs, internal rejection, and deterministic strongly connected cycle paths	available
Modulith	Module tests	Focused transitive dependency graphs, dependency-first package selection, and exact ordinary Go test execution are available	available
Modulith	Event publication registry	Transactional outbox messages, driver-neutral SQL persistence, lease/completion/release contracts, at-least-once dispatch, and bounded observations are available; the PostgreSQL integration supplies deterministic migration DDL plus atomic ordered SKIP LOCKED leasing with real-container transaction, retry, stale-owner, and concurrency verification; management views remain optional integration work	integration
Modulith	Documentation	Read-only JSON canvases plus deterministic Mermaid and PlantUML module diagrams	available
Modulith	Runtime observations	Generated module ownership plus synchronous lifecycle and typed publisher-to-subscriber interaction seams are available; the opt-in OpenTelemetry adapter emits bounded spans and delivery metrics containing compiler-owned event, publisher module, subscriber module, subscriber, order, and outcome identities without payloads or error text	integration
Current bootstrap	Annotation parser, declaration scan, and target metadata	Valid comment syntax, source association, typed built-in definitions, and target diagnostics	available
Current bootstrap	Go-native annotation SDK	Explicit file-scoped named, aliased, and namespace imports resolve fail-closed to one-file public sdk.Definition descriptors, while namespace imports can also bind ordinary Go interface packages for compiler-owned DI type resolution; every invocation in every file requires a matching import and no product path consults a built-in registry or annotation-name fallback; namespace imports statically discover every exported exact func() sdk.Definition in descriptor packages; descriptor packages join the single typed program and are decoded without execution; exact target-module tool authorization, offline Go module/replacement provenance, bounded framed SDK/server messages, persistent per-workspace processes, strict identity/descriptor-package/handler negotiation, full Windows/Unix process-tree cancellation, bounded stderr, and no replay are available; the validated typed contribution union drives application, stereotype construction, explicit interface binding, bean selection/scope metadata, provider, configuration, enum, module, lifecycle, web, security, data, schedule, event, cache, bootstrap, and guarded-output semantics without descriptor-name switches; the existing v1alpha2 invocation-facts map now has a bounded generic function-result namespace that preserves readable alias spelling while exposing compiler-supplied unaliased canonical identity, effective underlying Go kind, and generic named origin without adding a wire field or annotation-specific compiler logic; all 33 official descriptors use the external core tool, commerce uses explicit imports, and list/doctor plus verify/generate/build/run/dev/LSP share the tool-aware pipeline; rich descriptor-backed import/annotation completion, documentation, signature help, real definition/navigation for descriptors, handlers, and interface operands are available; annotation/sdk/sdktest gives third parties a public-only deterministic handler harness, and the independent fixture module proves named aliases, namespace resolution, plugin diagnostics, provider generation, ownership checking, and offline build/run	available
Current bootstrap	Shared diagnostics	Stable namespaced codes, severity, physical URI/path and half-open ranges, source-mapped display locations, related information, version-aware safe edits, deterministic immutable sets, and spice.diagnostics/v1 verification output are consumed by generate/build/run/dev plus versioned LSP diagnostics, completion, hover, safe code actions, and semantic annotation presentation through the shared overlay compiler service	available
Current bootstrap	Provider dependency validation	Exact concrete and explicit named-interface candidate resolution, deterministic missing/ambiguity diagnostics, cycle detection, and dependency-first metadata	available
Current bootstrap	Provider cleanup metadata	Named context-aware cleanup result validation retained for future generated rollback and shutdown	available
Current bootstrap	Lifecycle hook metadata	Exact provider-owned @OnStart/@OnStop validation plus direct generated execution through the lifecycle coordinator	available
Current bootstrap	Application roots and immutable IR	Preferred annotated package-main discovery loads one bounded local package scope without dummy imports, while the compatible legacy form retains exact parameter roots; both carry ordered provider, graph, cleanup, lifecycle, module, and normalized qualified bootstrap metadata without executing marker bodies	available
Current bootstrap	Lifecycle runtime coordination	Explicit callback state machine with dependency-order start, reverse stop/cleanup, startup rollback, idempotency, and caller-owned contexts	available
Current bootstrap	Deterministic generation plan	Pure target-scoped Go rendering with named contracts/configuration/providers/assembly/features/HTTP/lifecycle/command concerns, stable per-route units, one mirrored sources/<package>/<source>_spice_gen.go unit per contributing handwritten file, Go-safe internal_/vendor_ encoding for reserved nested import boundaries while retaining exact source metadata, source-owned application metadata/direct provider construction/configuration binding/interface assertions, OpenAPI under artifacts/, explicit generated-package entrypoints, typed singleton components, stable imports, canonical schema-5 SHA-256 concern-role/primary-source/related-source/generated-range metadata, guarded schema-4 monolith and schema-3 adjacent-shard/bridge migration, and executable generated fixtures	available
Current bootstrap	Safe generation and build commands	Rooted ownership checks, manual-edit refusal, no-op preservation, check/diff, stale recovery, target locks, and trimpath build	available
Current bootstrap	Executable generated reference	Spice’s production CLI, Commerce, and Petclinic explicitly import committed generated target packages backed by compile-time module/provider discovery, typed components and overrides, configuration, lifecycle, freshness checks, and bounded shutdown; Spice additionally injects its runtime and 15 ordered CLI handler interface beans through reviewed auto-configuration, proves per-handler typed replacement, spicetest, LSP streams, source navigation, a cycle-free seven-module self-hosting canvas, focused module testing, a sub-minute warm dogfood gate, an independent ordinary-Go recovery compiler, and a clean-room spice new plus hash-guarded spice add workflow that generates from zero output and vendors/builds/runs offline, while Petclinic proves embedded assets, localized HTML, three compile-time persistence graphs, and real browser interaction	available
Current bootstrap	Engineering quality and reproducible builds	Go-owned cross-platform core orchestration provides changed-package plus reverse import/test-import feedback through make fast and enforces Go formatting, lint, nil-safety, security, fuzz, race, coverage, vendor, executable checks, and reviewed median time/memory/allocation budgets for model construction, rendering, warm editor analysis, and CLI parsing; its mandatory two-stage bootstrap/recovery proof builds and audits the ordinary-Go compiler offline without generated dependencies, checks and executes the production generated Spice application through both stages, rejects any unexpected generated target, generates and executes an isolated app from zero output, proves byte-identical regeneration, rejects manual generated edits, and recovers from zero again. The independent Zed repository owns pinned Rust formatting, tests, Clippy, its locked wasm32-wasip2 release build, and an offline canonical Spice fixture. The independent GoLand repository owns its checksum-pinned Gradle/Java 25 build, compiler warnings-as-errors, real platform/color/folding tests, light/Darcula rendering, archive validation, Plugin Verifier, and installed Windows/Linux UI gates against exact core and Petclinic commits. The repository-owned offline release builder produces deterministic trimpath CLI archives for Windows/Linux/macOS amd64/arm64, an SPDX 2.3 SBOM, SHA-256 checksums, and an Ed25519 signature from a clean exact tag without GoReleaser or another dependency resolver; executable getting-started, Spring migration, dogfooding-boundary, and upgrade guides document the supported path	available

Coverage rules

Every row must resolve to available, integration, or not-planned. not-planned requires an adjacent deliberate rationale and a Go-native replacement. The repository quality gate rejects unresolved or unknown states, so release readiness cannot be created by leaving roadmap labels ambiguous. These statuses never override the pre-alpha maturity statement or the package API classification.

Every new area must define:

1. The developer-facing API.
2. The generated or runtime behavior.
3. Failure diagnostics.
4. Security defaults.
5. Unit and integration tests.
6. A runnable example.
7. The intended Spring capability relationship.