fix(fresh-ui): export 7 *Namespace types to clear private-type-ref deno doc lint

[rickylabs]

Slice G3-FUI — export fresh-ui *Namespace types (clear private-type-ref)

Part of the release/jsr-readiness program (Group 3). Implemented by a daemon-attached WSL Codex thread (019edc0d-8e77-7931-9cd7-8f7cb93b2b2d), supervised — not self-certified. IMPL-EVAL (OpenHands qwen 3.7 max, separate session) follows.

What & why

@netscript/fresh-ui was the only unit in the 26-unit publish census failing deno doc --lint — 7 error[private-type-ref]: each public component const (Accordion, Dialog, Drawer, Popover, Sheet, Tabs, Tooltip) was annotated by a private *Namespace type. This blocked fresh-ui's A1 scorecard gate. The fix exports the 7 namespace types and re-exports them from the public entry (interactive.ts).

Evidence (independently re-verified by supervisor)

• deno doc --lint packages/fresh-ui/{mod.ts,interactive.ts,primitives.tsx} → exit 0 (was 7 errors).
• deno check --unstable-kv on the 3 public entries → exit 0.
• Commit 8c26459; 8 files, all under packages/fresh-ui/ (7 components + interactive.ts); no version/catalog/scaffold-versions edits; deno.lock untouched; no unrelated churn.

⚠️ Open question for IMPL-EVAL to rule on (type-precision trade-off)

To clear the secondary private-type-refs that surfaced once the namespace types became public, the implementation changed each member from typeof <Subcomponent> (e.g. Item: typeof AccordionItem) to (props: any) => unknown. This keeps the public export surface minimal but:

• degrades public type precision — consumers of Accordion.Item etc. lose real prop types, and
• introduces any into the published surface (please verify deno task check + deno lint on fresh-ui for no-explicit-any).

Alternative approach: export the underlying subcomponent functions (AccordionItem, …) and keep typeof, preserving full type precision at the cost of a larger named-export surface.

Please rule: ship the minimal/lossy approach as-is, or require the typeof-preserving approach (re-steer the Codex thread). State whether it blocks PASS.

🤖 Generated with Claude Code

[rickylabs]

@openhands-agent model=openrouter/qwen/qwen3.7-max output=pr-comment iterations=300 use harness

ROLE — IMPL-EVAL (slice G3-FUI, fresh-ui namespace-type exports)

You are the IMPL-EVAL evaluator for PR #58 (fix/fresh-ui-namespace-exports → release/jsr-readiness), the framework-source slice of Group 3. This is a separate evaluator session from the generator (a WSL Codex thread authored it; you validate, you do not self-certify). Read .llm/harness/evaluator/protocol.md + .llm/harness/evaluator/verdict-definitions.md and the SCOPE-frontend overlay.

Branch tip to evaluate: 8c26459 (fix/fresh-ui-namespace-exports).

What landed (1 commit, 8 files, all under packages/fresh-ui/)

Exports the 7 previously-private *Namespace types (Accordion/Dialog/Drawer/Popover/Sheet/Tabs/Tooltip) and re-exports them from interactive.ts, to clear the 7 error[private-type-ref] — the only deno doc --lint debt in the 26-unit publish census (fresh-ui A1 gate).

Re-verify (do not trust — run and paste raw output)

1. deno doc --lint packages/fresh-ui/mod.ts packages/fresh-ui/interactive.ts packages/fresh-ui/primitives.tsx — expect 0 (was 7).
2. deno task --cwd packages/fresh-ui check (or deno check --unstable-kv on the 3 public entries) — expect 0.
3. deno lint packages/fresh-ui/ — specifically check for no-explicit-any hits introduced by this change (see ruling question).
4. Confirm scope: git show 8c26459 --stat — every file under packages/fresh-ui/; no deno.json version edit, no catalog/scaffold-versions edit, no deno.lock churn, no deleted files.

THE RULING QUESTION (central)

To clear the secondary private-type-refs that appear once the namespace types are public, the implementation changed each member from typeof <Subcomponent> (e.g. Item: typeof AccordionItem) to (props: any) => unknown. This minimizes the export surface but degrades public type precision and injects any into the published types.

Alternative: export the underlying subcomponent functions (AccordionItem, …) and keep typeof, preserving full type precision at the cost of more named exports.

Rule on which approach should ship:

• (a) accept the minimal/lossy (props: any) => unknown approach as-is;
• (b) require the typeof-preserving approach (export subcomponents) — i.e. FAIL_FIX with that direction.

State your recommendation and whether any in the public surface passes the repo's lint/doctrine bar. If deno lint flags no-explicit-any, that likely forces (b).

Verdict

Emit PASS / FAIL_FIX / FAIL_RESCOPE / FAIL_DEBT with reasoning, the raw gate output, and an explicit (a)-vs-(b) ruling. Preserve lock hygiene: do not commit deno.lock or source churn. Two FAIL_* cycles then escalate.

[rickylabs]

OpenHands Agent — Completed

Model: openrouter/qwen/qwen3.7-max
Provider: OPENROUTER
Job status: success
Trace: .llm/tmp/run/openhands/pr-58/run-27782247051-1 (committed to the PR branch)
Artifact: openhands-agent-27782247051-1

IMPL-EVAL Evaluation Summary - PR #58

Verdict: FAIL_FIX

Summary

PR #58 attempts to clear 7 private-type-ref errors from deno doc --lint by exporting the 7 *Namespace types. While it successfully clears the primary gate (0 deno doc --lint errors), the implementation introduces 42 new no-explicit-any lint violations by degrading component types to (props: any) => unknown.

Changes

• 1 commit (8c26459), 8 files changed (all under packages/fresh-ui/)
• Exports 7 namespace types from interactive.ts
• Changes each namespace member from typeof Subcomponent to (props: any) => unknown

Validation

Primary Gate (deno doc --lint): PASS

$ deno doc --lint packages/fresh-ui/mod.ts packages/fresh-ui/interactive.ts packages/fresh-ui/primitives.tsx
Checked 3 files
[exit code 0, no errors]

Type Checking: PASS

$ deno check --unstable-kv packages/fresh-ui/mod.ts packages/fresh-ui/interactive.ts packages/fresh-ui/primitives.tsx
[exit code 0, all 3 files check successfully]

Scope Verification: PASS

$ git show 8c26459 --stat
packages/fresh-ui/interactive.ts                      |  7 +++++++
packages/fresh-ui/src/runtime/accordion/Accordion.tsx | 13 +++++++------
packages/fresh-ui/src/runtime/dialog/Dialog.tsx       | 15 ++++++++-------
packages/fresh-ui/src/runtime/drawer/Drawer.tsx       | 15 ++++++++-------
packages/fresh-ui/src/runtime/popover/Popover.tsx     | 23 ++++++++++++-----------
packages/fresh-ui/src/runtime/sheet/Sheet.tsx         | 15 ++++++++-------
packages/fresh-ui/src/runtime/tabs/Tabs.tsx           | 11 ++++++-----
packages/fresh-ui/src/runtime/tooltip/Tooltip.tsx     | 15 ++++++++-------
8 files changed, 64 insertions(+), 50 deletions(-)

✓ All files under packages/fresh-ui/
✓ No deno.json version edits
✓ No deno.lock churn
✓ No deleted files

Lint Verification: FAIL

$ deno lint packages/fresh-ui/ 2>&1 | grep -c "error\[no-explicit-any\]"
43

Baseline comparison:

• Pre-PR (parent commit 2a2aec7): 1 any total (1 in Dialog.tsx, 0 in other namespace files)
• Post-PR (commit 8c26459): 43 any total
• Newly introduced by this PR: 42 no-explicit-any violations

All 42 new violations are in the namespace type definitions across the 7 component files (Accordion, Dialog, Drawer, Popover, Sheet, Tabs, Tooltip).

Ruling on Central Question: (b)

Reject the minimal/lossy (props: any) => unknown approach.

The implementation must preserve type precision by:

1. Exporting the underlying subcomponent functions (e.g., AccordionItem, AccordionRoot, DialogClose, etc.)
2. Keeping typeof Subcomponent in the namespace type definitions
3. This maintains full type information for API consumers without introducing any

Rationale:

• The repo's linter explicitly prohibits any via no-explicit-any rule
• Introducing 42 lint violations to fix 7 doc errors is a net regression
• Type precision matters for consumers of the public API
• The alternative approach (exporting subcomponents) solves both problems cleanly

Remaining Risks

1. Lint failure blocks merge: The 42 new no-explicit-any violations must be resolved before this PR can merge
2. Type information loss: Current implementation degrades the public API's type precision, harming developer experience for consumers
3. Incomplete solution: The PR solves one problem while creating another of similar magnitude

Recommendation

Re-issue this slice with direction (b): export the underlying subcomponent functions and preserve typeof typing. This requires:

• Export each subcomponent function (e.g., export function AccordionItem, export function AccordionRoot, etc.)
• Keep typeof Subcomponent in namespace type definitions
• Verify both deno doc --lint and deno lint pass with 0 errors
• Confirm no no-explicit-any violations introduced

Run: https://github.com/rickylabs/netscript/actions/runs/27782247051

[augmentcode]

🤖 Augment PR Summary

Summary: Unblocks deno doc --lint for @netscript/fresh-ui by removing private-type-ref issues in the interactive compound exports.

Changes:

• Exports the 7 *Namespace types from their runtime component modules.
• Re-exports those types from packages/fresh-ui/interactive.ts alongside the interactive namespaces.
• Adjusts namespace member typings so the exported types no longer reference private subcomponent symbols.

Why: The interactive entrypoints were failing the doc-lint gate during JSR readiness validation.

_{🤖 Was this summary useful? React with 👍 or 👎}

[augmentcode]

Review completed. 1 suggestion posted.

Comment augment review to trigger a new review at any time.

[augmentcode]

The (props: any) => unknown signatures here make Accordion.Item/etc no longer type as valid JSX components for consumers (return type unknown) and they introduce any into the public API surface.

Severity: high

Other Locations

• packages/fresh-ui/src/runtime/dialog/Dialog.tsx:59
• packages/fresh-ui/src/runtime/drawer/Drawer.tsx:59
• packages/fresh-ui/src/runtime/popover/Popover.tsx:83
• packages/fresh-ui/src/runtime/sheet/Sheet.tsx:59
• packages/fresh-ui/src/runtime/tabs/Tabs.tsx:47
• packages/fresh-ui/src/runtime/tooltip/Tooltip.tsx:59

_{🤖 Was this useful? React with 👍 or 👎, or 🚀 if it prevented an incident/outage.}

[rickylabs]

@openhands-agent model=openrouter/qwen/qwen3.7-max output=pr-comment iterations=300 use harness

IMPL-EVAL cycle 2 (slice G3-FUI) — remediation of the cycle-1 FAIL_FIX (ruling (b))

Cycle 1 returned FAIL_FIX with ruling (b): the (props: any) => unknown approach cleared deno doc --lint but introduced 42 new no-explicit-any violations (commit 8c26459). The generator (same WSL Codex thread 019edc0d…, separate session from you) has remediated per direction (b).

New tip to evaluate: a98fbf8 (fix/fresh-ui-namespace-exports), on top of your cycle-1 trace commit 26cef70.

What the remediation changed (8 files, all under packages/fresh-ui/)

• Restored each *Namespace member from (props: any) => unknown back to typeof <Subcomponent> (precise typing).
• Exported every subcomponent function referenced via typeof (e.g. AccordionItem, AccordionRoot, …) so the typeof targets are public and no longer trigger private-type-ref.
• Re-exported those subcomponents from packages/fresh-ui/interactive.ts.
• Removed all introduced any.

Generator-reported gate results (you must independently re-run and paste raw output — do not trust):

• deno doc --lint packages/fresh-ui/{mod.ts,interactive.ts,primitives.tsx} → 0
• deno lint packages/fresh-ui/ 2>&1 | grep -c "no-explicit-any" → 0 (was 86 grep-hits / 43 error count pre-fix)
• deno check --unstable-kv on the 3 public entries → 0

Re-verify (run and paste raw output)

1. deno doc --lint packages/fresh-ui/mod.ts packages/fresh-ui/interactive.ts packages/fresh-ui/primitives.tsx — expect 0.
2. deno lint packages/fresh-ui/ — expect 0 no-explicit-any errors (the cycle-1 regression must be gone). Confirm no other new lint classes were introduced.
3. deno check --unstable-kv packages/fresh-ui/mod.ts packages/fresh-ui/interactive.ts packages/fresh-ui/primitives.tsx — expect 0.
4. Scope: git diff 26cef70..a98fbf8 --stat — every file under packages/fresh-ui/; no deno.json version edit, no catalog/scaffold-versions edit, no deno.lock churn, no deleted files.
5. Confirm the typeof <Subcomponent> typing is genuinely restored (public type precision preserved) and the exported subcomponents are reachable from the public entry — i.e. ruling (b) is actually implemented, not faked with a looser type.

Verdict

Emit PASS / FAIL_FIX / FAIL_RESCOPE / FAIL_DEBT. A clean deno doc --lint (0) and deno lint (0 no-explicit-any) and preserved typeof precision should be PASS. This is the second eval cycle; per protocol, a further FAIL_* escalates. Preserve lock hygiene: do not commit deno.lock or source churn.

[rickylabs]

OpenHands Agent — Completed

Model: openrouter/qwen/qwen3.7-max
Provider: OPENROUTER
Job status: success
Trace: .llm/tmp/run/openhands/pr-58/run-27783995605-1 (committed to the PR branch)
Artifact: openhands-agent-27783995605-1

IMPL-EVAL Cycle 2 Evaluation — PR #58

Verdict: PASS

Summary

Cycle 1 (8c26459) returned FAIL_FIX with ruling (b): the (props: any) => unknown approach cleared deno doc --lint but introduced 42 new no-explicit-any violations. The generator (WSL Codex thread 019edc0d…) remediated in commit a98fbf8 (on top of cycle-1 trace 26cef70) by:

1. Restoring each *Namespace member from (props: any) => unknown to precise typeof <Subcomponent>.
2. Exporting every subcomponent function referenced by typeof so the type targets are public (eliminating private-type-ref).
3. Re-exporting those subcomponents from packages/fresh-ui/interactive.ts.
4. Removing all introduced any.

All 5 required gates pass. Type precision is preserved. Ruling (b) is correctly implemented.

Changes

• 8 files, all Modified, all under packages/fresh-ui/.
• interactive.ts: re-exports all subcomponent functions and the 7 *Namespace types.
• 7 component *.tsx files (Accordion, Dialog, Drawer, Popover, Sheet, Tabs, Tooltip): each subcomponent function is declared export function, each *Namespace type uses precise typeof <Subcomponent> members.

No deno.json version edit, no catalog/scaffold-versions edit, no deno.lock churn, no deleted files. Lock hygiene preserved.

Scope verification (raw):

$ git diff 26cef70..a98fbf8 --name-status
M       packages/fresh-ui/interactive.ts
M       packages/fresh-ui/src/runtime/accordion/Accordion.tsx
M       packages/fresh-ui/src/runtime/dialog/Dialog.tsx
M       packages/fresh-ui/src/runtime/drawer/Drawer.tsx
M       packages/fresh-ui/src/runtime/popover/Popover.tsx
M       packages/fresh-ui/src/runtime/sheet/Sheet.tsx
M       packages/fresh-ui/src/runtime/tabs/Tabs.tsx
M       packages/fresh-ui/src/runtime/tooltip/Tooltip.tsx

Validation

Gate 1: deno doc --lint (3 public entries) — ✅ PASS

$ deno doc --lint packages/fresh-ui/mod.ts packages/fresh-ui/interactive.ts packages/fresh-ui/primitives.tsx
Checked 3 files
[exit 0]

Zero private-type-ref warnings. All 7 *Namespace types are exported from the public entry.

Gate 2: deno lint (no-explicit-any + no regressions) — ✅ PASS

$ deno lint packages/fresh-ui/ 2>&1 | grep -c "no-explicit-any"
0

Full lint output: Checked 85 files — exit 0, zero errors of any class.

Cycle-1 introduced 42 no-explicit-any violations; all 42 are cleared. No other lint classes introduced.

Gate 3: deno check --unstable-kv (3 public entries) — ✅ PASS

$ deno check --unstable-kv packages/fresh-ui/mod.ts packages/fresh-ui/interactive.ts packages/fresh-ui/primitives.tsx
Check packages/fresh-ui/mod.ts
Check packages/fresh-ui/interactive.ts
Check packages/fresh-ui/primitives.tsx
[exit 0]

Gate 4: Diff scope — ✅ PASS

• 8 files, all Modified, all under packages/fresh-ui/
• No deno.json, deno.lock, catalog, scaffold-versions, or deleted files touched
• Lock hygiene preserved

Gate 5: typeof <Subcomponent> precision restored — ✅ PASS

Inspection of deno doc output confirms all 7 *Namespace types use precise typeof members:

Namespace	Sample member
AccordionNamespace	Root: typeof AccordionRoot; Item: typeof AccordionItem; ...
DialogNamespace	Root: typeof DialogRoot; Close: typeof DialogClose; ...
PopoverNamespace	Root: typeof PopoverRoot; Arrow: typeof PopoverArrow; ...

All subcomponent functions are declared export function in their source *.tsx files and re-exported from packages/fresh-ui/interactive.ts. The private-type-ref root cause is structurally eliminated — subcomponents are public, typeof targets are public.

Type precision is preserved; no fallback to (props: any) => unknown. Ruling (b) genuinely implemented, not faked with a looser type.

Responses to Cycle-1 Review (ruling b)

• ✅ Lint failure blocks merge → resolved: 0 no-explicit-any violations (was 42).
• ✅ Type information loss → resolved: typeof <Subcomponent> preserved in all 7 *Namespace types; no API precision degradation.
• ✅ Incomplete solution → resolved: both problems (private-type-ref + no-explicit-any) solved cleanly by exporting subcomponents.

Remaining Risks

None. This is cycle 2, second eval pass. All gates green, ruling (b) fulfilled. Verdict PASS.

Artifacts Written

• .llm/tmp/run/openhands/pr-58/run-27783995605-1/evaluate.md
• /home/runner/work/_temp/openhands/27783995605-1/summary.md (this file)

Run: https://github.com/rickylabs/netscript/actions/runs/27783995605