Portable contribution proof

Bounded prototype accepted, 2026-10-04

cc872a2 closes the implementation gaps in the bounded inspector experiment. Native Devframe/DevTools and Chrome/Firefox execute the same contracts/actions/JSON view, including replacement rendering, mixed-provider selection, actual response/marker effects, failures/recovery, production watch/preview and caller-disconnect behavior. Five new issue-scoped commits add actual packed native and extension consumption, the optional CDB disabled profile, extension failure recovery and development source-edit proof.

The detailed closeout records exact commands, versions, outcomes, DOR/DONE and proof limits. Every prototype API/hook has a concrete example/test entry. Local evidence validates 105 references across 60 files and 584 distinct referenced checks; broader SDK inventory remains 814 paths, 460 linked paths and 38 groups with gaps. Final full CI passes. Its downloaded artifacts independently verify all 584 referenced browser checks and 362 linked unit-test references.

The owner accepted the bounded experiment on 2026-10-04 after its walkthrough and live Devframe/DevTools demos, and authorized continued implementation. No prototype contract revision was requested. This closes the bounded proof; broader host/surface/lifecycle and release cells remain in their owning contracts.

Part of Design a portable contribution SDK and WebExtension runtime.

Upstream integration boundary, 2026-09-27

The proof composes the existing declarations, native hosts, renderer and adapters. It must not introduce a showcase-only startHost abstraction or a second set of contribution APIs. Different native bootstrap code is expected; shared UI/contracts are the portability proof.

See the implementation and map review. This narrows implementation mechanisms without dropping the accepted feature or real-host coverage requirements.

Question

Can one contribution, authored with the existing JSON rendering format, run through Devframe, Devtools, Chrome extension, and Firefox extension hosts while preserving the selected operation, state, injection, and reload contracts?

Choose and run a bounded prototype that answers this question with executable examples. The result must expose an abstraction failure early enough to change the design before the framework's public API hardens.

Context and current behavior

The destination is a generic framework built in the devkit-extension pnpm/Turbo monorepo. Contributions are build-time npm packages and may contain UI only, actions only, transforms only, realm implementations, or any composition. The default renderer reuses existing JSON authoring and can be replaced by a renderer built with another framework.

The same feature must have host implementations that report their capabilities honestly. Raw APIs stay local behind typed contexts, with realm, execution context, and UI surface modeled separately. Optional CDB support means a working adapter when enabled, not an unused interface reserved for future work.

This experiment tests whether one feature works without hidden host dependencies. Its success does not certify future SDK features; the complete matrix remains a release requirement.

Requirements and scope

Use a generic "response inspector" contribution. Its UI shows a selected target, provider availability, one shared configuration value, the latest inspection result, and action outcomes. It can read a fixture response, request a deterministic modification where supported, install a page-side marker, and reset its state. The fixture application must be owned by the repository and serve predictable HTML and HTTP responses.

Package the authored JSON UI independently from implementations. Reuse that same authored UI through all selected hosts and a replacement renderer. Include small standalone examples for UI-only, action-only, transform-only, and realm-implementation contributions so composition does not become a mandatory all-in-one package shape.

The experiment must exercise development HMR, watch-build reload, and live preview with visible retention behavior. Demonstrate provider selection, unavailable operations, and failures. Every public prototype API and hook needs runnable examples under Examples and API coverage contract.

Options and recommendation

A static JSON preview verifies rendering but leaves transport and lifecycle assumptions untouched. A Chrome-only demonstration verifies one extension path while concealing browser-specific behavior. Building the complete framework first would postpone the most expensive design feedback.

Recommend one narrow feature running end to end across every selected host. Use a deterministic repository fixture instead of a third-party site. Keep real browser execution in the experiment. A fake transport is useful for focused failure tests but cannot establish Chrome or Firefox compatibility.

Run the optional CDB adapter as an explicitly enabled profile against its actual integration. Its absence must produce the documented optional-capability result in the default profile. If any required behavior cannot be supplied on a host, revise the contract or record the supported alternative with the human before declaring the experiment successful.

Proposed API or experiment

Illustrative pseudocode showing the intended separation:

export const inspectorPlugin = definePlugin({
  id: 'example:response-inspector',
  views: [inspectorJsonView],
  actions: [inspectResponseAction, updateConfigurationAction],
  transforms: [fixtureResponseTransform],
});

const provider = await createDevframeProvider({
  context: actualHubContext,
  providerId: 'example:server',
  plugins: [inspectorPlugin],
});
// Native host creation/mounting stays native. Its shutdown awaits provider.dispose().

definePlugin and createDevframeProvider are maintained exports with the shown single-object provider input. Shared registration is now implemented through defineView, defineScript and defineTransform, each taking { id, execution, requires?, setup } and the existing typed capability/native context and cleanup scope. The accepted transform contract and current evidence supersede the former unsupported-envelope checkpoint. The response-inspector composition is now implemented in the linked executable slice. Its bounded owned endpoint, all four host implementations, both renderers, recipient selection and selected packed-consumer checks have live evidence. The broader SDK matrix remains unfinished. Extension hosts install the same plugin through their own native integration. Host launchers may differ, but authored UI and action identifiers remain shared. Handlers receive typed local contexts; RPC payloads contain validated portable data.

Provide documented pnpm commands for the fixture application, contribution package, renderer preview, Devframe host, Devtools host, Chrome extension host, Firefox extension host, and optional CDB profile. Each command must start an observable example, or explain its prerequisite and start command. Include a reproducible browser interaction sequence and save the resulting test evidence.

Use package filters locally and CI for the full matrix. Record versions and build mode to distinguish development-preview evidence from packaged-extension evidence.

Scenarios and acceptance criteria

The unchanged JSON view displays state and invokes an action through Devframe, Devtools, Chrome, and Firefox hosts.
A second renderer consumes the same authored view and preserves action and state behavior.
UI-only, action-only, transform-only, and realm-implementation examples initialize independently and dispose cleanly.
The page marker appears at the promised timing boundary. The fixture verifies actual response bytes or DOM effects according to the selected injection contract.
Unsupported transform behavior remains visible and follows the agreed fallback policy without silently pretending to modify a response.
Provider selection changes the action destination. A failed provider yields a provider-specific error without corrupting sibling state.
Development edits and packaged watch-build changes trigger the documented layer's reload and retain exactly the declared state.
Tests exercise cancellation or disconnection during a call, malformed state, denied permissions, and teardown with active subscriptions.
The real optional CDB adapter completes its enabled-profile example and has an expected disabled-profile outcome.

All prototype public APIs, hooks, and features must have matrix entries, runnable examples, and tests for their supported hosts and expected unsupported/failure paths.

Dependencies

Injection and transform contract, Renderer and surface contract, Live preview and reload contract, and Examples and API coverage contract block this experiment. They define what counts as success and which evidence must be produced. Consume the chosen contribution, routing, and state contracts; report contradictions as decision findings rather than repairing their policy silently.

Definition of Ready

All fixture APIs resolve to maintained exports or explicitly named unresolved domain contracts.
Blocking contracts specify observable behavior and testable host support.
The generic fixture and bounded response-inspector behavior are agreed.
Browser runners and optional CDB prerequisites are available or explicitly identified as blockers.

Definition of Done

The proof uses packed public packages and the same contribution/JSON spec across native and extension hosts without private imports or a new orchestration framework.
Runnable artifacts and exact commands are linked with recorded versions and outcomes.
Every prototype API and hook has a complete example/test/host matrix entry.
Real Chrome and Firefox runs verify supported paths and expected failures.
The human reviews the experiment, and any contract revisions are recorded in their owning decisions.

Resolution record

Technical evidence is recorded in the closeout. Final CI passes and its evidence is independently verified. The owner accepted the bounded experiment on 2026-10-04. 75491b0 records that review without changing implementation or contracts. Unexercised cells are explicitly named; prototype completion does not replace the full SDK release gates.

Research handoff and acceptance gates

Sources: Toolchain and reload audit.

Accountable owner: dvcol, until reassigned. These observations inform this open contract; they do not resolve it.

WXT is a conditional packaging candidate. Both WXT and a small custom Vite host executed a shared action/state/content fixture on stable Chromium and Firefox. The fixture did not implement the portable SDK or mount the reference renderer.

Before adopting WXT in this proof, make the retained declaration minimum pass with full library checking and settle the reload integration required by the approved contract. Do not turn the experiment's WXT-only skipLibCheck workaround into a portable-package setting. The custom Vite candidate is a viable fallback, with explicit ownership of missing extension/content reload machinery.

The proof must exercise the approved contribution and real renderer through valid public host contexts across both server hosts and both browsers. Keep fresh-generation, lifecycle and unavailable-path assertions from the research handoffs.

Implementation claim and bounded composition, 2026-10-03

This proof remains open for a concrete missing application. The maintained counter, renderer, native script/response-filter and debugger receipts prove its ingredients, but none is the independently authored response inspector required here. Packed cross-host consumption and human review also remain unfinished. The open status of other broad tickets is not the sole reason for this status.

The native APIs needed to begin are available. I have claimed the ticket and started the smallest shared authoring module, native JSON publication and host implementations. These are example contributions using maintained exports; no SDK contract or host-launcher abstraction is being introduced.

The proposed composition uses one shared inspector capability and four actions: read the owned response, change its deterministic modification configuration, install a marker for future documents, and reset owned configuration/results/future marker registration. Provider business state stays native and separate. The authored JSON view displays selected response URL, configuration, modification availability/reason, latest status/body, marker installation and action outcome.

Shared JSON view
  -> existing action binding and realm/provider selection
  -> shared inspector action
  -> selected provider's inspector service
       Vite: owned endpoint + native HTML hook
       Firefox: native page execution + StreamFilter
       Chromium: native page execution + explicit filtering unavailability
  -> that provider's native shared state and view projection

The fixed repository endpoint is /inspector-response, with original text fixture:original and supported modified text native:fixture:original. Extension resource selection belongs to its service and requires one owned fixture tab. Native failures remain rejected operations. Reset affects future owned resources and state; it does not roll back old documents. Ordinary Chromium filtering remains explicitly unavailable; the optional CDB profile is still a separate acceptance item.

Native Vite preview serves built HTML and cannot install a new HTML marker through transformIndexHtml after the build. That operation will reject clearly in preview while response inspection/configuration remain available. No replacement HTML-transform pipeline is planned.

Definition of Ready for the first slice:

Maintained declarations, native server/extension APIs and browser runners exist.
The fixed owned fixture and native boundaries can reuse settled contracts.

Definition of Done remains pending: shared JSON/action/state across all four real hosts and a replacement renderer; marker/response bytes; provider selection/failure isolation; documented reload/retention; optional CDB enabled/disabled; packed public consumption; exact bounded matrix; and human review. The first authoring/host files are not evidence that this full proof is complete.

feat(example): compose response inspector across native hosts (#15)

Shared inspector composition delivered

a589b0a composes one shared capability, four action contracts and one authored native JSON spec through genuine Devframe, DevTools, Chromium and Firefox hosts. It adds no SDK API or orchestration layer.

The implementation record contains the ownership diagram, exact public calls, commands and limitations. Native Vite middleware owns one fixture endpoint; Firefox filters only the selected top-level fixture document's response. Chromium visibly reports filtering unavailable and rejects enabling it. No resource identity enters transport routing.

Measured results:

Chromium 153.0.8010.12: both simultaneous native server hosts pass ten checks with zero page/console errors and distinct provider state.
Chromium extension: six checks, zero page errors, original bytes retained after unavailable modification.
Firefox 157.0/geckodriver0.37.1: seven checks, actual prefixed bytes, same-tab navigation to another document untouched. No global page-error capture is claimed.
Native marker runs before the next document's first parser script; reset removes future registration/effects while retaining already-executed document effects.
Affected packages pass 7 contribution, 8 JSON-render, 34 native Vite-host and 38 WebExtension cases; strict TypeScript7, type-aware Oxlint and formatting pass. The integration also corrected the background unit fixture at its native browser I/O boundary, preserving the exact existing startup-failure assertion.

Definition of Ready for this slice:

All composition APIs resolve to maintained exports and native contexts.
Owned deterministic fixtures and existing browser prerequisites are available.

Definition of Done for this slice:

Same authored UI and imported actions execute on all four host implementations.
Exact native receipts are retained only after cleanup and linked by the conformance matrix.
Scoped source checks and affected-package tests pass.
Full CI for a589b0a passes; downloaded artifacts independently verify 58 browser references across 41 receipt files and 441 referenced native checks, with all 7/8/34/38 affected-package cases passing.

The full ticket remains open. Packed consumption, this exact spec on a replacement renderer, mixed-provider inspector broadcast/partial failure, standalone Firefox server UI, inspector development/watch-build/preview retention, cancellation/disconnection races, optional CDB enabled profile and human review remain explicit acceptance work. The next independent work targets packed contracts and standalone Firefox evidence.

test(example): consume packed inspector contracts (#15)

test(example): verify inspector renderer portability (#15)

Packed contracts and renderer proof delivered

be8b0f3 extends the real tarball consumer. Strict Bundler and NodeNext consumers import the inspector public subpath, preserve boolean configure input/result inference, reject the corresponding string values, and execute all four actions plus direct capability reads through packed runtime. The browser contract graph stays limited to installed core/example contracts and Zod; host, runtime, Node and framework leakage still fails the check.

6ecd9c4 makes the existing framework-free example renderer consume the exact authored inspector. Its former colon-only action restriction and blanket callback rejection were example limitations. Public JSON core helpers now resolve portable action identifiers and execute state-setting callbacks. Mount-local outcomes survive native provider projections. No SDK API, dependency or spec transformation was added for rendering.

Implemented calls:

const action = resolveAction(binding, localState.getSnapshot());
await executeAction({
  action,
  handler: (params) => nativeRpcCall(action.action, params),
  setState: localState.set,
});
// Native business/view state stays provider-owned; callbacks change only this mount.

The updated record and commands link actual native receipts. Chromium 153.0.8010.12 passes 18 checks with zero page/console errors; Firefox 157.0/geckodriver 0.37.1 passes 20 checks with explicit visible-failure assertions and no global error-capture claim. Both cover genuine Devframe and DevTools servers, fresh same-provider peers, all five custom buttons, mount-local outcome preservation, renderer replacement/reset and clicking a disposed control without a provider effect. Existing counter-renderer regressions also pass 18 Chromium and 16 Firefox checks.

Definition of Ready:

Exact inspector spec fits the existing DOM catalog; public core helpers cover its callback semantics.
Existing native browser/dependency conventions are available. Selenium pins are reused by the server example.

Definition of Done for these slices:

Packed contract consumers run independently of workspace links with strict inferred input/results.
Both browsers execute the exact spec with reference/custom rendering through both actual native hosts.
Scoped lint, TypeScript7, formatting, package tests and live regressions pass. Retained receipts preserve actual parsed observations; Chromium receipt receives enforced formatting only.
Matrix references pass locally at 814 paths, 460 linked paths, 61 browser references, 42 distinct receipt files and 471 referenced native checks; 38 groups retain explicit gaps.
CI at 6ecd9c4 failed in a core compiler-fixture deadline before browser jobs ran. 8bb42de corrects that deadline; replacement full CI passes. Its downloaded artifacts independently verify all 61 browser references, 42 distinct receipt files and 471 referenced native checks, including the new inspector reference/custom renderer observations.

This comment records the packed-contract/renderer checkpoint. Later native preview, mixed-provider, error/recovery and packed native-view proofs are delivered in the following #15 comment; remaining complete-host browser I/O, extension custom rendering, watched inspector builds, cancellation races, optional CDB profile and human review stay open.

Native preview, mixed providers, error recovery and packed native views delivered

The shared response inspector now exercises the agreed client selection and provider ownership across actual backends. These are native compositions and tests; no SDK API, auth/serialization protocol, transport policy or host supervisor was added.

Commit	Reviewable change	Executed proof
20f2eb9	Real Vite preview with dynamically installed shared inspector definitions	Eight Devframe/DevTools cases: actual original/modified/reset response bytes; marker rejection before changing native state or built HTML; independent script/transform/service disposal. Affected Vite example suite passes 42 tests.
78f8eb0	Packaged Chromium panel with extension plus both native server providers	Nine checks: realm-only and explicit-provider selection, independent URLs/state and identical view keys, Chromium rejection beside both server successes, future marker/reset, and isolated disconnected-provider failure.
2c491a5	Actual inspector onError and recovery with both renderers	Four native host/renderer cells per browser. One real HTTP failure per cell executes authored `Inspection failed`, preserves prior state and shows the native error. Reset and Inspect recover on the same provider, mount and document.
7985240	Packaged Firefox panel with the same three-provider composition	Eight checks: all three providers modify their own response bytes, selectors preserve siblings, markers/reset and disconnect isolation remain correct.
eb6fd0c	Installed native inspector action/view consumer	Real tarballs, strict Bundler/NodeNext and both native context types prove publication/index, exact action references, projected state and independent view/service/action disposal. Browser mounting and HTTP effects remain separate proof.

The mixed fixtures reuse the existing private createRemoteContext helper and Devframe's public initHub, native origin options and interactive-auth tokens on real Vite servers. Hub middleware mounts through Vite's setup hook. Each connection owns its authentication and state. The mixed proof tests standalone native context composition; separate inspector page tests cover the native Vite plugin bootstrap.

// Existing declarations and routing, unchanged.
createInspectorActions({ execution: serverExecution });
createInspectorView({ execution: serverExecution, nativeContext: devframeHubContext });

// Existing embedding API; every connection has its own native policy.
initHub({ context, server: viteServer.httpServer,
  allowedOrigins: [extensionOrigin],
  auth: createInteractiveAuth(context, { clientAuthTokens: [temporaryToken] }),
  /* existing fixture lifecycle options */
});

// Existing recipient shapes used by the panel.
const serverRecipients = [{ realm: 'devserver' }];
const selectedServer = [{ realm: 'devserver', provider: 'example.devframe' }];
const allRecipients = [{ realm: 'devserver' }, { realm: 'webext' }];

An all-provider configure in Chromium returns one rejected and two fulfilled outcomes. The unchanged native success callback reports dispatch completion; the outcome array and projected unavailable reason show the rejection. A routed single-provider read failure rejects instead and runs authored onError. Closing Devframe makes its outcome catalog-unknown; DevTools and the extension still complete, with no rerouting. Provider capabilities choose their own owned response endpoint/document. The transport interprets no domain or tab rule.

Commands, ownership diagram and retained raw observations describe the exact boundaries. Chromium 153.0.8010.12 captures zero unhandled page/console errors for error/recovery and zero page errors for mixed broadcast. Firefox 157.0/geckodriver 0.37.1 asserts visible errors, connection/overlay state and recovery; WebDriver Classic supplies no global browser-error capture. Receipts are retained after successful assertions and cleanup and independently compared with their generated payloads.

Definition of Ready:

Shared action/view contracts and maintained native preview/connection/renderer APIs already exist.
Owned fixtures admit deterministic real HTTP failures, separate native state and native future-document effects without production test seams.
Existing tarball installation policy and native dependency patches can be reused without manifest edits or workspace links.

Definition of Done for these slices:

Actual native preview, Chromium/Firefox mixed broadcast and eight host/renderer error-recovery observations pass.
Installed tarball consumers execute native action/view/state/disposal in strict Bundler and NodeNext.
Scoped strict lint, TypeScript7, formatting and affected tests pass; conformance links pass locally.
Separate issue-scoped commits are pushed to main.
Local inventory records 814 public paths, 460 linked paths, 71 browser references across 46 receipt files and 494 referenced native checks. All 38 partial groups retain explicit gaps.
Full CI at eb6fd0c passes; all 71 downloaded browser references across 46 receipt files were independently checked, containing 494 referenced native checks. Downloaded core/runtime/Vite/WebExtension suites contain 142/94/42/38 passing tests.

The prior full CI at 8bb42de is verified green, with 471 referenced native checks across 42 files. It does not include these latest slices. Packed browser/native host I/O, extension custom rendering/error recovery, watched inspector builds/browser preview/reload, cancellation races, optional CDB profile and human review remain open. Investigation continues on extension custom rendering and the existing production/watch composition. The native debugger integration remains an optional capability.

feat(example): render inspector with shared extension renderer (#15)

feat(example): run inspector through native production preview (#15)

test(example): verify inspector after native caller disconnect (#15)

Extension renderer, watched production and native caller disconnect

Three separate reviewable commits extend the existing response-inspector proof. Shared contracts, authored JSON, native action bindings and provider-owned resource selection stay unchanged. No SDK API, transport policy or recovery supervisor was added.

Commit	Change	Actual proof
7fca561	Packaged framework-free example renderer and extension selector	Chrome seven checks and Firefox six checks. The same panel actions preserve realm/provider/all-provider selection, independent native state and expected Chrome partial rejection. Reference/custom replacement and disconnect dispose the old controls; retained detached buttons cannot dispatch.
5e64512	Shared native inspector declarations in development, build watch and preview	Chrome and Firefox each verify seven production scenarios on both native backends with both renderers. A real syntax failure retains complete assets and live state; fresh failure-era clients receive that generation. Repair publishes a new generation while old documents, provider identities and old asset bytes remain. Runtime marker rejection and shutdown cleanup are explicit.
0ccbe1b	Pinned caller-disconnect proof	Chrome and Firefox each verify five checks on both native hosts. The sender leaves while one real response request is held. Its captured native sockets close; the observer and backend work survive. Release completes that request once, updates retained state without changing incarnation, leaves the alternate host unchanged and allows fresh mounting without replay.

Implemented native composition:

// Private example exports, shared across development and preview.
const feature = createInspectorFeature();
const provider = await createDevframeProvider({
  context: actualNativeContext,
  ...inspectorComposition(feature, 'devframe'),
});

// The existing framework-free renderer is packaged for the extension.
import { domRenderer } from '@devkit/example-json-render/renderer';
// The host passes the same native entry/context/action binding to either renderer.

The independent commands are inspector:build:watch and inspector:preview. inspector:dev:production runs their pnpm regex in parallel. A direct CLI check started watcher plus preview for each native backend, observed ready status and real built HTML, then stopped the owned preview. DEVKIT_HOST=devtools selects DevTools; Devframe is the default. Vite owns build/watch/preview, and the existing publication helper retains the last complete generation. Existing documents do not automatically reload in production.

Caller disconnection does not cancel already-dispatched native backend work or roll back state. The proof inspects actual socket/request/state observations; it does not inspect the abandoned document Promise or configure an available fallback selector. Extension and preview races remain separate cells. Renderer replacement alone does not cancel the Vite page's connection lifetime.

Built preview rejects runtime page-marker changes before state or HTML mutation. Native errors belong to the failed action, so a successful read does not clear a prior marker error. DevTools connection discovery probes the absent Devframe metadata endpoint first. Chrome retains its actual 404s and allows only that exact request/status and corresponding console message. Other browser errors fail. Firefox Classic asserts visible errors, state and connection but provides no global page/console/discovery capture.

Detailed composition, diagrams, runnable commands and raw observations contain all proof boundaries. Tested Chrome is 153.0.8010.12; Firefox is 157.0 with geckodriver 0.37.1. Generated receipts were compared byte-for-byte with retained evidence after assertions and cleanup.

Definition of Ready:

Existing native renderer, action binding, host composition and production publication hooks are available.
Owned HTTP fixtures provide real failure/held-request boundaries without production test seams.
The new extension renderer export preserves the existing implementation and uses generated declarations.

Definition of Done for these slices:

Custom extension rendering, production watch/preview and pinned caller disconnect pass on both browsers/native host combinations described above.
Scoped strict lint, TypeScript7, formatting, affected builds and all 42 Vite example tests pass.
Direct unified CLI checks prove watcher and preview readiness and owned preview shutdown.
Maintained browser commands, CI steps, matrix references and raw receipts are linked.
Three issue-scoped commits are pushed to main; separate pending manual-permission files remain untouched.
Local conformance checks validate 85 browser references across 52 receipt files and 531 referenced native checks. Inventory remains 814 public paths, 460 linked paths and 38 groups with explicit gaps.
Corrective full CI at a7cba43 passes. Its downloaded receipts independently validate all 85 references, 52 files and 531 referenced native checks. The preceding run exposed a compiler-test deadline mismatch, corrected in the separate Examples and API coverage contract #14 commit; it did not reach browser execution.

The preceding full CI at eb6fd0c is independently verified green with 494 referenced native checks. It does not include these three commits. Complete tarball/browser/native host I/O, extension native failure recovery, broader inspector development/reload and race cells, optional CDB profile and human prototype review remain open. The next tarball proof will reuse the actual native inspector feature rather than an in-memory replacement service. No new architectural choice blocks these independent slices.

test(example): run packed inspector through native browser hosts (#15)

test(example): verify default profile without debugger authority (#15)

test(example): verify native extension inspector failure recovery (#15)

test(example): verify native inspector development source recovery (#15)

test(example): consume packed inspector extension in both browsers (#15)

Bounded prototype technical closeout

The remaining inspector implementation gaps now have actual evidence. Five separate commits keep the proof reviewable and add no public SDK mechanism. The same capability, action contracts and authored JSON view remain shared; providers own native resources and renderers consume the native JSON contract.

Commit	Delivered behavior
202d8ca	Isolated tarball consumer imports the actual inspector feature/composition and both renderers. Chromium runs twelve checks across native Devframe/DevTools HTTP, authenticated WebSockets, state projection, future marker timing, reset and detached-control disposal.
1e03e4a	Optional CDB disabled profile builds a real permission-free extension. No service or debugger API exists, its action waits and rejects with unavailable-capability, and the owned page receives zero title evaluations. Existing enabled/native/Firefox profiles remain separate evidence.
3808289	Actual extension HTTP failure and recovery run in Chrome/Firefox with both renderers and a native Devframe sibling. The extension rejects while the sibling succeeds. Prior state, incarnation, document and mount survive; Reset/Inspect recover.
0bdaff7	Chrome/Firefox each execute eight main-module edit checks on both native hosts. Valid edit reloads, actual syntax failure displays the native overlay and removes controls, and repair restores the authored view with the same provider/state. Each host observes three HTTP responses for three explicit clicks, with no reload replay.
cc872a2	The unchanged extension application builds in an isolated tarball consumer. Its unchanged production inspector runners pass six Chrome and seven Firefox checks. Worker, panel and injection module graphs cannot resolve workspace source, Node imports or external chunks.

The API/hook acceptance table links every bounded prototype use to its executed example and states its limits. Composition, ownership diagrams, exact commands and retained raw observations remain the executable reference.

Reproduce the new proofs

Build the affected dependency graph first as described in the composition document. These are scoped checks.

node scripts/check-native-packages.ts
node scripts/check-native-packages.ts --browser
SE_DRIVER_VERSION=0.37.1 SE_SKIP_DRIVER_IN_PATH=true node scripts/check-native-packages.ts --extension-browser
pnpm --filter @devkit/example-debugger exec node tests/chromium-disabled.ts
pnpm --filter @devkit/example-webext exec node tests/inspector-errors-chromium.ts
SE_DRIVER_VERSION=0.37.1 SE_SKIP_DRIVER_IN_PATH=true pnpm --filter @devkit/example-webext exec node tests/inspector-errors-firefox.ts
pnpm --filter @devkit/example-vite-hosts exec node tests/inspector-development-chromium.ts
SE_DRIVER_VERSION=0.37.1 SE_SKIP_DRIVER_IN_PATH=true pnpm --filter @devkit/example-vite-hosts exec node tests/inspector-development-firefox.ts

Use FIREFOX_BINARY when Firefox is outside driver discovery. Tested versions are Chrome 153.0.8010.12 and Firefox 157.0/geckodriver 0.37.1. All three artifact-gate branches pass; generated extension/development/error receipts match the retained JSON values after formatting and resource cleanup.

Behavior and proof boundaries

Client selection chooses realm/provider recipients. Capability implementations choose their own resources. The transport does not interpret domains or browser targets.
Native broadcast returns recipient outcomes, including rejection, so its authored success callback reports dispatch completion. A routed invocation rejection uses onError. Native error text remains generic remotely. No second error-disclosure or retry policy was added.
Native Vite module reload keeps its existing authentication prompts. Tests answer the actual prompt with the terminal code. Development provider/state survives browser-module reload; backend-source HMR and extension-source edits remain parent-contract cells.
Production preview keeps the last complete generation; existing pages navigate explicitly to a new one. Runtime marker installation rejects before modifying preview state or built HTML.
Caller disconnect does not cancel already-dispatched native unary backend work or roll it back. The existing held-request proof observes its completion and retained state without replay.
Chrome response filtering remains explicitly unavailable; Firefox filtering is confined to the selected owned document. Firefox Classic cannot claim global page/console error capture. Inspector permission denial is tested at the native scripting boundary; the pending manual Chrome prompt is a separate authority test.
Packed extension execution uses the reference renderer. Its custom/mixed-provider cells have separate native workspace proofs; native packed Chromium exercises both renderers. This is not an exhaustive packaging cross-product.
CDB remains an ordinary optional title capability with native target/grant/lease semantics. It is not a fifth realm or an inspector-specific orchestration layer.

Definition of Ready

All fixture API uses resolve to maintained exports or explicitly native APIs.
Observable ownership, availability, routing and cleanup behavior is specified.
The bounded repository-owned response/HTML fixture is agreed.
Actual browser and optional CDB prerequisites are available with exact versions.

Definition of Done

Installed tarballs and actual native/extension hosts consume the same contracts and authored JSON view, without private SDK imports or a new orchestration framework.
Artifacts, exact commands, versions, outcomes and every prototype API/hook entry are linked.
Real Chrome/Firefox runs cover the selected supported paths and expected failures.
Scoped strict Oxlint, TypeScript7, Oxfmt and affected build checks pass.
Local conformance validates 105 browser references across 60 files, containing 584 distinct referenced checks. Inventory remains 814 public paths, 460 linked paths and 38 groups with explicit broader gaps.
Full CI at cc872a2 passes. Downloaded artifacts independently verify all 105 browser references, 60 receipt files, 584 distinct browser checks and 362 linked unit-test references. All linked reports have zero failed tests.
The owner reviews the actual prototype and accepts it or identifies revisions.

The preceding corrective full CI at a7cba43 is independently verified green with 531 checks. This ticket stays open only for the required owner review of the bounded prototype. The complete SDK release obligations remain in their owning tickets. The separate manual Chrome permission files remain untouched, and two peer-lifecycle upstream drafts still await approval. The independently reproduced state-echo bug is Devframe draft 422, with reproduction steps and passing upstream CI.

44eb6db reconciles only the two maintained readout paragraphs with verified implementation CI. Scoped Oxfmt and staged checks pass; implementation code is unchanged from the green cc872a2 run.

docs(example): reconcile verified inspector prototype acceptance (#15)

docs(example): record owner acceptance of portable prototype (#15)

Resolution: bounded prototype accepted

On 2026-10-04 the owner reviewed the explanation, validation sequence and live Devframe/DevTools demos, then said "Seems good for now" and authorized continued implementation. No prototype API or ownership revision was requested.

The answer to this ticket is yes for the bounded response-inspector feature. One capability, four action contracts and one authored native JSON view run on the two native server hosts and both extension browsers, with a replaceable renderer. Clients choose recipients; providers choose their native resources and retain independent state. Native auth, RPC, state, rendering and build lifecycle remain upstream-owned.

Implementation closeout, accepted API/hook table, and walkthrough and commands hold the detailed evidence. Full implementation CI passes with independently verified 105 browser references, 60 receipt files, 584 referenced checks and 362 linked unit references. The acceptance-only commit passes scoped formatting and staged checks; it changes no runtime code.

Definition of Done is complete for this bounded experiment. Broader SDK state, authority, injection, renderer, reload, packaging and release obligations remain in their owning contracts. Chromium response filtering is explicitly unavailable in this example; native broadcast outcomes, authentication after reload and already-dispatched backend work retain the documented behavior. This acceptance does not certify all 814 public paths or erase the 38 broader gap groups.

Continue with State scope and recovery before expanding the dependent renderer and reload work. Manual Chrome permission interaction and the two unapproved peer-lifecycle drafts remain separate owner inputs; neither prevents this independent state work.

Navigation Menu

Repository navigation

Portable contribution proof #15

Bounded prototype accepted, 2026-10-04

Upstream integration boundary, 2026-09-27

Question

Context and current behavior

Requirements and scope

Options and recommendation

Proposed API or experiment

Scenarios and acceptance criteria

Dependencies

Definition of Ready

Definition of Done

Resolution record

Research handoff and acceptance gates

Implementation claim and bounded composition, 2026-10-03

Shared inspector composition delivered

Packed contracts and renderer proof delivered

5 remaining items

Native preview, mixed providers, error recovery and packed native views delivered

Extension renderer, watched production and native caller disconnect

Bounded prototype technical closeout

Reproduce the new proofs

Behavior and proof boundaries

Definition of Ready

Definition of Done

Resolution: bounded prototype accepted

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Portable contribution proof #15

Description

Bounded prototype accepted, 2026-10-04

Upstream integration boundary, 2026-09-27

Question

Context and current behavior

Requirements and scope

Options and recommendation

Proposed API or experiment

Scenarios and acceptance criteria

Dependencies

Definition of Ready

Definition of Done

Resolution record

Activity

dvcolomban commented on Sep 22, 2026

Research handoff and acceptance gates

dvcolomban commented on Oct 3, 2026

Implementation claim and bounded composition, 2026-10-03

dvcolomban commented on Oct 3, 2026

Shared inspector composition delivered

dvcolomban commented on Oct 3, 2026

Packed contracts and renderer proof delivered

5 remaining items

dvcolomban commented on Oct 3, 2026

Native preview, mixed providers, error recovery and packed native views delivered

dvcolomban commented on Oct 3, 2026

Extension renderer, watched production and native caller disconnect

dvcolomban commented on Oct 3, 2026

Bounded prototype technical closeout

Reproduce the new proofs

Behavior and proof boundaries

Definition of Ready

Definition of Done

dvcolomban commented on Oct 4, 2026

Resolution: bounded prototype accepted

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions