@rightkit/onboarding 0.0.0-stage → 0.2.0

package/LICENSE-APACHE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/LICENSE-MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Adrian D'souza
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,42 @@
-# Temporary Holding Version
+# @rightkit/onboarding
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+First-run onboarding framework for Right Suite apps: a legal agreement gate first, then ordered steps (permissions, model download, licence/trial, plus app-defined steps) with progress, skip and resume.
+
+```tsx
+import { Onboarding } from "@rightkit/onboarding";
+import "@rightkit/onboarding/onboarding.css";
+
+<Onboarding settings={settings} legal={legal} permissions={permissions} models={models} license={license}
+  onComplete={finish} onSkip={later} />
+```
+
+- `settings` is a `SettingsBackend`; progress is stored under the `onboarding.state` key.
+- The agreement is enforced until accepted, regardless of the saved step index. Acceptance is stored as `legalAcceptance: { version, documentsHash, acceptedAt (UTC ISO), eligibilityBasis }`; legacy `legalAccepted: true` is still read.
+- `onComplete` and `onSkip` run only after the state was saved. A rejected save is shown in an alert and neither callback runs.
+
+## Props
+
+| Prop | Purpose |
+| --- | --- |
+| `requiredVersion` | Version the user must have accepted. A different or missing stored version re-prompts with the legal gate's `re-acceptance` variant. Legacy boolean acceptance is only re-prompted when this is set. |
+| `isAccepted(state)` | Custom acceptance check; overrides `requiredVersion`. |
+| `documentsHash` | Hash recorded with the acceptance (default: SHA-256 of document titles and URLs). |
+| `beforeLegalGate()` | Awaited before the gate shows (e.g. size or reveal the window). The package does no window sizing itself. |
+| `requireModel` | Continue/Finish on the models step wait for an installed model. |
+| `autoStartDownload` | Start the first missing model download when the models step opens. |
+| `modelsIntro` | App copy shown at the top of the models step. |
+| `allowSkip` | Show "Set up later" (default `true`). |
+| `titlebar` | Node rendered in a strip along the top. |
+| `dragRegion` | Add `data-tauri-drag-region` to that strip (default `false`; height `--rk-onboarding-titlebar-h`, default 32px). |
+
+## Custom steps and readiness
+
+A step may set `canContinue(context)`; Continue/Finish stay disabled while it returns `false` (optional `blockedHint` is shown). Steps with async readiness call `context.setReady(boolean)` from `render` and read `context.ready[stepId]`. Back is disabled on the first step after the agreement.
+
+## Models backend
+
+`ModelsBackend.cancel` is optional; the Pause control appears only when it is supplied.
+
+## Tests
+
+`pnpm exec vitest run` runs the jsdom unit tests (`src/*.test.tsx`) and the headless-Chrome e2e.

package/dist/Onboarding.d.ts

@@ -0,0 +1,5 @@
+import type { OnboardingProps, PersistedOnboardingState } from "./types.js";
+/** True when the stored acceptance satisfies the host's requirement. */
+export declare function isLegalAccepted(state: PersistedOnboardingState, requiredVersion?: string, custom?: (state: PersistedOnboardingState) => boolean): boolean;
+export declare function onboardingStateKey(): string;
+export declare function Onboarding({ settings, legal, steps, permissions, models, license, onComplete, onSkip, className, requiredVersion, isAccepted, documentsHash, beforeLegalGate, requireModel, autoStartDownload, modelsIntro, allowSkip, titlebar, dragRegion }: OnboardingProps): import("react").JSX.Element;

package/dist/Onboarding.js

@@ -0,0 +1,178 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { LegalGate } from "@rightkit/legal-ui";
+import { Button } from "@rightkit/app-shell/react";
+import { cx } from "./ui.js";
+import { licenseStep, modelsStep, permissionsStep } from "./steps.js";
+const KEY = "onboarding.state";
+const INITIAL = { version: 1, currentStep: 0, completed: [], skipped: false, legalAccepted: false };
+function readAcceptance(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const r = value;
+    if (typeof r.version !== "string" || typeof r.documentsHash !== "string" || typeof r.acceptedAt !== "string")
+        return undefined;
+    if (r.eligibilityBasis !== "individual" && r.eligibilityBasis !== "enterprise")
+        return undefined;
+    return { version: r.version, documentsHash: r.documentsHash, acceptedAt: r.acceptedAt, eligibilityBasis: r.eligibilityBasis };
+}
+function readState(value) {
+    if (!value || typeof value !== "object")
+        return INITIAL;
+    const candidate = value;
+    const legalAcceptance = readAcceptance(candidate.legalAcceptance);
+    return {
+        version: 1,
+        currentStep: typeof candidate.currentStep === "number" && candidate.currentStep >= 0 ? Math.floor(candidate.currentStep) : 0,
+        completed: Array.isArray(candidate.completed) ? candidate.completed.filter((x) => typeof x === "string") : [],
+        skipped: candidate.skipped === true,
+        legalAccepted: candidate.legalAccepted === true || legalAcceptance !== undefined,
+        eligibilityBasis: legalAcceptance?.eligibilityBasis ?? (candidate.eligibilityBasis === "individual" || candidate.eligibilityBasis === "enterprise" ? candidate.eligibilityBasis : undefined),
+        ...(legalAcceptance ? { legalAcceptance } : {}),
+    };
+}
+/** True when the stored acceptance satisfies the host's requirement. */
+export function isLegalAccepted(state, requiredVersion, custom) {
+    if (custom)
+        return custom(state);
+    if (requiredVersion !== undefined)
+        return state.legalAcceptance?.version === requiredVersion;
+    return state.legalAccepted;
+}
+/** FNV-1a fallback when SubtleCrypto is unavailable. */
+function fnv(text) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < text.length; i += 1) {
+        h ^= text.charCodeAt(i);
+        h = Math.imul(h, 0x01000193) >>> 0;
+    }
+    return `fnv1a:${h.toString(16).padStart(8, "0")}`;
+}
+async function hashDocuments(documents) {
+    const text = JSON.stringify(documents.map((d) => [d.title, d.url ?? ""]));
+    try {
+        const subtle = globalThis.crypto?.subtle;
+        if (subtle) {
+            const digest = await subtle.digest("SHA-256", new TextEncoder().encode(text));
+            return `sha256:${[...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+        }
+    }
+    catch { /* fall through */ }
+    return fnv(text);
+}
+export function onboardingStateKey() { return KEY; }
+function TitleStrip({ titlebar, dragRegion }) {
+    if (!titlebar && !dragRegion)
+        return null;
+    return _jsx("div", { className: "rk-onboarding__titlebar", "data-testid": "onboarding-titlebar", ...(dragRegion ? { "data-tauri-drag-region": "" } : {}), children: titlebar });
+}
+export function Onboarding({ settings, legal, steps = [], permissions, models, license, onComplete, onSkip, className, requiredVersion, isAccepted, documentsHash, beforeLegalGate, requireModel, autoStartDownload, modelsIntro, allowSkip = true, titlebar, dragRegion }) {
+    const [state, setState] = useState(null);
+    const [saving, setSaving] = useState(false);
+    const [error, setError] = useState(null);
+    const [readyMap, setReadyMap] = useState({});
+    const [gateCleared, setGateCleared] = useState(false);
+    /** Persists a patch; throws when the settings backend rejects it. */
+    const persist = useCallback(async (patch) => {
+        setSaving(true);
+        setError(null);
+        const next = { ...(state ?? INITIAL), ...patch };
+        try {
+            const snap = await settings.patch({ [KEY]: next });
+            setState(readState(snap.values[KEY]));
+        }
+        catch (e) {
+            setError(e instanceof Error ? e.message : String(e));
+            throw e;
+        }
+        finally {
+            setSaving(false);
+        }
+    }, [settings, state]);
+    /** Like `persist` but reports success as a boolean; the failure is already visible via `error`. */
+    const save = useCallback(async (patch) => {
+        try {
+            await persist(patch);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }, [persist]);
+    const saveStep = useCallback(async (patch) => { await save(patch); }, [save]);
+    useEffect(() => { let live = true; void settings.load().then((snapshot) => { if (live)
+        setState(readState(snapshot.values[KEY])); }, (e) => { if (live)
+        setError(e instanceof Error ? e.message : String(e)); }); return () => { live = false; }; }, [settings]);
+    const builtins = useMemo(() => [
+        { id: "legal", label: "Agreement", title: "Review agreement", skippable: false, render: () => _jsx("p", { className: "rk-onboarding__muted", children: "Agreement accepted." }) },
+        ...(permissions ? [permissionsStep(permissions)] : []),
+        ...(models ? [modelsStep(models, { required: requireModel, autoStartDownload, intro: modelsIntro })] : []),
+        ...(license ? [licenseStep(license)] : []),
+        ...steps,
+    ], [license, models, permissions, steps, requireModel, autoStartDownload, modelsIntro]);
+    const activeState = state ?? INITIAL;
+    const accepted = isLegalAccepted(activeState, requiredVersion, isAccepted);
+    const needsGate = state !== null && !accepted;
+    // The agreement gate does not depend on the saved step: until it is accepted, the active step is the first.
+    // Once accepted, the Agreement step (index 0) is never shown again when other steps exist.
+    const index = !accepted ? 0 : builtins.length > 1 ? Math.max(1, Math.min(activeState.currentStep, builtins.length - 1)) : 0;
+    const active = builtins[index];
+    const activeId = active?.id ?? "";
+    const setReady = useCallback((ready) => setReadyMap((m) => m[activeId] === ready ? m : { ...m, [activeId]: ready }), [activeId]);
+    useEffect(() => {
+        if (!needsGate) {
+            setGateCleared(false);
+            return;
+        }
+        if (gateCleared)
+            return;
+        let live = true;
+        void (async () => { try {
+            await beforeLegalGate?.();
+        }
+        catch (e) {
+            if (live)
+                setError(e instanceof Error ? e.message : String(e));
+        } if (live)
+            setGateCleared(true); })();
+        return () => { live = false; };
+    }, [needsGate, gateCleared, beforeLegalGate]);
+    const context = { state: activeState, settings, setState: saveStep, permissions, models, license, ready: readyMap, setReady };
+    const canContinue = active?.canContinue ? active.canContinue(context) : true;
+    const runCallback = async (callback) => {
+        try {
+            await callback?.();
+        }
+        catch (e) {
+            setError(e instanceof Error ? e.message : String(e));
+        }
+    };
+    const markAndMove = async (nextIndex, completedId) => {
+        const completed = completedId && !activeState.completed.includes(completedId) ? [...activeState.completed, completedId] : activeState.completed;
+        if (nextIndex >= builtins.length) {
+            if (await save({ completed, currentStep: Math.max(0, builtins.length - 1), skipped: false }))
+                await runCallback(onComplete);
+            return;
+        }
+        await save({ completed, currentStep: nextIndex, skipped: false });
+    };
+    if (error && !state)
+        return _jsxs("div", { className: cx("rk-onboarding", className), children: [_jsx("p", { className: "rk-onboarding__error", role: "alert", children: error }), _jsx(Button, { onClick: () => window.location.reload(), children: "Retry" })] });
+    if (!state || !active)
+        return _jsx("div", { className: cx("rk-onboarding", className), "aria-busy": "true", children: _jsx("p", { className: "rk-onboarding__muted", children: "Loading setup\u2026" }) });
+    if (needsGate) {
+        if (!gateCleared)
+            return _jsxs("div", { className: cx("rk-onboarding", className), "aria-busy": "true", children: [_jsx(TitleStrip, { titlebar: titlebar, dragRegion: dragRegion }), _jsx("p", { className: "rk-onboarding__muted", children: "Loading setup\u2026" })] });
+        const reacceptance = activeState.legalAccepted || activeState.legalAcceptance !== undefined;
+        return _jsxs("div", { className: cx("rk-onboarding rk-onboarding--legal", className), "data-testid": "onboarding-legal", "data-variant": reacceptance ? "re-acceptance" : "first-run", children: [_jsx(TitleStrip, { titlebar: titlebar, dragRegion: dragRegion }), _jsx(LegalGate, { ...legal, variant: reacceptance ? "re-acceptance" : "first-run", onQuit: () => void legal.onQuit?.(), onAgree: async ({ eligibilityBasis }) => {
+                        const legalAcceptance = { version: requiredVersion ?? "1", documentsHash: documentsHash ?? await hashDocuments(legal.documents), acceptedAt: new Date().toISOString(), eligibilityBasis };
+                        const progress = reacceptance ? {} : { completed: ["legal"], currentStep: builtins.length > 1 ? 1 : 0 };
+                        await persist({ legalAccepted: true, eligibilityBasis, legalAcceptance, ...progress });
+                        if (!reacceptance && builtins.length === 1)
+                            await onComplete();
+                    } })] });
+    }
+    const body = active.render(context);
+    return _jsxs("main", { className: cx("rk-onboarding", className), "data-testid": "onboarding", "data-step-id": active.id, children: [_jsx(TitleStrip, { titlebar: titlebar, dragRegion: dragRegion }), _jsxs("aside", { className: "rk-onboarding__rail", children: [_jsx("div", { className: "rk-onboarding__brand", children: legal.appName }), _jsx("nav", { "aria-label": "Setup progress", children: builtins.map((step, i) => _jsxs("button", { type: "button", className: cx("rk-onboarding__step", i === index && "is-active", activeState.completed.includes(step.id) && "is-done"), "aria-current": i === index ? "step" : undefined, disabled: i === 0 && builtins.length > 1, onClick: () => { if (i > 0 && (i <= index || canContinue))
+                                void save({ currentStep: i }); }, children: [_jsx("span", { children: activeState.completed.includes(step.id) ? "✓" : i + 1 }), step.label] }, step.id)) })] }), _jsxs("section", { className: "rk-onboarding__main", children: [_jsxs("header", { children: [_jsxs("p", { className: "rk-onboarding__eyebrow", children: ["Step ", index + 1, " of ", builtins.length] }), _jsx("h1", { children: active.title }), active.description ? _jsx("p", { className: "rk-onboarding__description", children: active.description }) : null] }), _jsx("div", { className: "rk-onboarding__content", children: body }), error ? _jsx("p", { className: "rk-onboarding__error", role: "alert", children: error }) : null, _jsxs("footer", { children: [allowSkip ? _jsx(Button, { variant: "ghost", disabled: saving, onClick: () => { void save({ currentStep: index, skipped: true }).then((ok) => ok ? runCallback(onSkip) : undefined); }, children: "Set up later" }) : null, _jsx("span", { className: "rk-onboarding__hint", children: !canContinue && active.blockedHint ? active.blockedHint : null }), _jsx(Button, { variant: "secondary", disabled: index <= 1 || saving, onClick: () => void save({ currentStep: index - 1 }), children: "Back" }), _jsx(Button, { variant: "primary", disabled: saving || !canContinue, onClick: () => void markAndMove(index + 1, active.id), children: index === builtins.length - 1 ? "Finish setup" : "Continue" })] })] })] });
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { Onboarding, isLegalAccepted, onboardingStateKey } from "./Onboarding.js";
+export { licenseStep, modelsStep, permissionsStep } from "./steps.js";
+export type { ModelsStepOptions } from "./steps.js";
+export type * from "./types.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { Onboarding, isLegalAccepted, onboardingStateKey } from "./Onboarding.js";
+export { licenseStep, modelsStep, permissionsStep } from "./steps.js";

package/dist/steps.d.ts

@@ -0,0 +1,24 @@
+import { type ReactNode } from "react";
+import type { LicenseBackend, ModelsBackend, OnboardingStep, PermissionsBackend } from "./types.js";
+export declare function permissionsStep(backend: PermissionsBackend, options?: {
+    label?: string;
+    title?: string;
+    description?: string;
+}): OnboardingStep;
+export interface ModelsStepOptions {
+    label?: string;
+    title?: string;
+    description?: string;
+    /** Continue/Finish wait until at least one model is installed. Default false. */
+    required?: boolean;
+    /** Start downloading the first missing model when the step opens. Default false. */
+    autoStartDownload?: boolean;
+    /** App copy rendered at the top of the step. */
+    intro?: ReactNode;
+}
+export declare function modelsStep(backend: ModelsBackend, options?: ModelsStepOptions): OnboardingStep;
+export declare function licenseStep(backend: LicenseBackend, options?: {
+    label?: string;
+    title?: string;
+    description?: string;
+}): OnboardingStep;

package/dist/steps.js

@@ -0,0 +1,100 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { Button, Input, Badge } from "@rightkit/app-shell/react";
+function ProgressBar({ value, label }) {
+    const pct = Math.max(0, Math.min(1, value));
+    return _jsx("div", { className: "rk-onboarding__progress", role: "progressbar", "aria-label": label, "aria-valuemin": 0, "aria-valuemax": 100, "aria-valuenow": Math.round(pct * 100), children: _jsx("i", { style: { width: `${pct * 100}%` } }) });
+}
+const formatBytes = (n) => {
+    if (n === undefined)
+        return "";
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let value = n;
+    let unit = 0;
+    while (value >= 1000 && unit < units.length - 1) {
+        value /= 1000;
+        unit += 1;
+    }
+    return `${value >= 100 || unit === 0 ? Math.round(value) : value.toFixed(1)} ${units[unit]}`;
+};
+const permissionTone = (state) => state === "ready" ? "ok" : state === "denied" || state === "restricted" ? "bad" : state === "needed" ? "warn" : "neutral";
+function PermissionsBody({ backend }) {
+    const [items, setItems] = useState([]);
+    const [busy, setBusy] = useState(null);
+    const [error, setError] = useState(null);
+    const reload = useCallback(() => backend.list().then(setItems, (e) => setError(e instanceof Error ? e.message : String(e))), [backend]);
+    useEffect(() => void reload(), [reload]);
+    return (_jsxs("div", { className: "rk-onboarding__card", "data-testid": "onboarding-permissions", children: [error ? _jsx("p", { className: "rk-onboarding__error", role: "alert", children: error }) : null, items.length === 0 && !error ? _jsx("p", { className: "rk-onboarding__muted", children: "Checking permissions\u2026" }) : null, items.map((item) => (_jsxs("div", { className: "rk-onboarding__row", "data-permission-id": item.id, children: [_jsxs("div", { children: [_jsx("strong", { children: item.label }), _jsx("p", { children: item.description ?? item.detail })] }), _jsxs("div", { className: "rk-onboarding__row-actions", children: [_jsx(Badge, { tone: permissionTone(item.state), children: item.state }), item.state === "needed" || item.state === "denied" ? (_jsx(Button, { size: "sm", variant: "secondary", disabled: busy === item.id, onClick: () => { setBusy(item.id); setError(null); void backend.request(item.id).then((next) => setItems((current) => current.map((x) => x.id === next.id ? next : x)), (e) => setError(e instanceof Error ? e.message : String(e))).finally(() => setBusy(null)); }, children: item.state === "denied" ? "Try again" : "Allow" })) : null] })] }, item.id)))] }));
+}
+export function permissionsStep(backend, options = {}) {
+    return { id: "permissions", label: options.label ?? "Permissions", title: options.title ?? "Allow what this app needs", description: options.description ?? "You can change these permissions later in System Settings.", skippable: true, render: () => _jsx(PermissionsBody, { backend: backend }) };
+}
+function ModelsBody({ backend, onReady, autoStartDownload, intro }) {
+    const [models, setModels] = useState([]);
+    const [loaded, setLoaded] = useState(false);
+    const [busy, setBusy] = useState(null);
+    const [error, setError] = useState(null);
+    const autoStarted = useRef(false);
+    const reload = useCallback(() => backend.list().then((list) => { setModels(list); setLoaded(true); }, (e) => setError(e instanceof Error ? e.message : String(e))), [backend]);
+    useEffect(() => {
+        void reload();
+        if (!backend.subscribe)
+            return;
+        let off;
+        let live = true;
+        void backend.subscribe((entry) => setModels((current) => current.some((m) => m.id === entry.id) ? current.map((m) => m.id === entry.id ? entry : m) : [...current, entry])).then((unsubscribe) => { if (live)
+            off = unsubscribe;
+        else
+            unsubscribe(); });
+        return () => { live = false; off?.(); };
+    }, [backend, reload]);
+    const hasInstalled = models.some((m) => m.state === "installed");
+    useEffect(() => { onReady?.(hasInstalled); }, [hasInstalled, onReady]);
+    const run = (id, request) => {
+        setBusy(id);
+        setError(null);
+        void request.then(reload, (e) => setError(e instanceof Error ? e.message : String(e))).finally(() => setBusy(null));
+    };
+    useEffect(() => {
+        if (!autoStartDownload || !loaded || autoStarted.current)
+            return;
+        autoStarted.current = true;
+        if (models.some((m) => m.state === "installed" || m.state === "downloading" || m.state === "verifying"))
+            return;
+        const first = models.find((m) => m.state === "missing");
+        if (first)
+            run(first.id, backend.install(first.id));
+        // run is intentionally omitted: it only closes over setters.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [autoStartDownload, loaded, models, backend]);
+    return (_jsxs("div", { className: "rk-onboarding__card", "data-testid": "onboarding-models", children: [intro ? _jsx("div", { className: "rk-onboarding__intro", "data-testid": "onboarding-models-intro", children: intro }) : null, error ? _jsx("p", { className: "rk-onboarding__error", role: "alert", children: error }) : null, models.map((model) => {
+                const progress = model.progress ?? (model.state === "installed" ? 1 : 0);
+                const active = model.state === "downloading" || model.state === "verifying";
+                const cancel = backend.cancel;
+                return _jsxs("div", { className: "rk-onboarding__row", "data-model-id": model.id, children: [_jsxs("div", { className: "rk-onboarding__grow", children: [_jsx("strong", { children: model.label }), _jsxs("p", { children: [model.description ?? "", model.sizeBytes ? ` · ${formatBytes(model.sizeBytes)}` : ""] }), active ? _jsx(ProgressBar, { value: progress, label: `${model.label} download` }) : null] }), _jsxs("div", { className: "rk-onboarding__row-actions", children: [_jsx(Badge, { tone: model.state === "installed" ? "ok" : model.state === "error" ? "bad" : "neutral", children: model.state }), model.state === "installed" ? null
+                                    : model.state === "error" ? _jsx(Button, { size: "sm", variant: "secondary", disabled: busy === model.id, onClick: () => run(model.id, backend.install(model.id)), children: "Retry" })
+                                        : active ? (cancel ? _jsx(Button, { size: "sm", variant: "secondary", disabled: busy === model.id, onClick: () => run(model.id, cancel.call(backend, model.id)), children: "Pause" }) : null)
+                                            : _jsx(Button, { size: "sm", variant: "secondary", disabled: busy === model.id, onClick: () => run(model.id, backend.install(model.id)), children: "Download" })] })] }, model.id);
+            }), models.length === 0 && !error ? _jsx("p", { className: "rk-onboarding__muted", children: "No models available." }) : null] }));
+}
+export function modelsStep(backend, options = {}) {
+    return {
+        id: "models", label: options.label ?? "Models", title: options.title ?? "Choose local models", description: options.description ?? "Downloads are verified before a model is activated.", skippable: true,
+        canContinue: options.required ? (ctx) => ctx.ready.models === true : undefined,
+        blockedHint: options.required ? "Download a model to continue." : undefined,
+        render: (ctx) => _jsx(ModelsBody, { backend: backend, onReady: ctx.setReady, autoStartDownload: options.autoStartDownload, intro: options.intro }),
+    };
+}
+function LicenseBody({ backend }) {
+    const [state, setState] = useState({ status: "none" });
+    const [key, setKey] = useState("");
+    const [busy, setBusy] = useState(false);
+    const [error, setError] = useState(null);
+    useEffect(() => void backend.load().then(setState, (e) => setError(e instanceof Error ? e.message : String(e))), [backend]);
+    const run = (fn) => { setBusy(true); setError(null); void fn().then(setState, (e) => setError(e instanceof Error ? e.message : String(e))).finally(() => setBusy(false)); };
+    return _jsxs("div", { className: "rk-onboarding__card", "data-testid": "onboarding-license", children: [_jsxs("div", { className: "rk-onboarding__license-state", children: [_jsx(Badge, { tone: state.status === "active" || state.status === "trial" ? "ok" : state.status === "expired" || state.status === "invalid" ? "bad" : "neutral", children: state.label ?? state.status }), _jsx("span", { children: state.detail ?? "You can continue without a licence." })] }), error ? _jsx("p", { className: "rk-onboarding__error", role: "alert", children: error }) : null, backend.activate ? _jsxs("form", { className: "rk-onboarding__form", onSubmit: (e) => { e.preventDefault(); if (key.trim())
+                    run(() => backend.activate(key.trim())); }, children: [_jsx(Input, { "aria-label": "Licence key", placeholder: "Licence key", value: key, onChange: (e) => setKey(e.target.value), disabled: busy }), _jsx(Button, { size: "sm", variant: "primary", type: "submit", disabled: busy || !key.trim(), children: "Activate" })] }) : null, _jsxs("div", { className: "rk-onboarding__row-actions", children: [backend.startTrial ? _jsx(Button, { size: "sm", variant: "secondary", disabled: busy, onClick: () => run(() => backend.startTrial()), children: "Start trial" }) : null, backend.purchaseUrl ? _jsx(Button, { size: "sm", variant: "ghost", onClick: () => void backend.openExternal?.(backend.purchaseUrl), children: "View plans" }) : null] })] });
+}
+export function licenseStep(backend, options = {}) {
+    return { id: "license", label: options.label ?? "Licence", title: options.title ?? "Choose how you’ll use this app", description: options.description ?? "Activate a licence, start a trial, or continue with the free plan.", skippable: true, render: () => _jsx(LicenseBody, { backend: backend }) };
+}

package/dist/types.d.ts

@@ -0,0 +1,139 @@
+import type { ReactNode } from "react";
+import type { LegalGateDocument, LegalGateProps, LegalGateTheme } from "@rightkit/legal-ui";
+export type SettingsValues = Record<string, unknown>;
+export interface SettingsSnapshot {
+    values: SettingsValues;
+    revision: number;
+}
+/** Structural port shared with @rightkit/settings-ui and rightkit-settings. */
+export interface SettingsBackend {
+    load(): Promise<SettingsSnapshot>;
+    patch(patch: SettingsValues, expectedRevision?: number): Promise<SettingsSnapshot>;
+    subscribe?(handler: (keys: string[]) => void): Promise<() => void>;
+}
+export type PermissionState = "ready" | "needed" | "waiting" | "denied" | "restricted";
+export interface PermissionStatus {
+    id: string;
+    label: string;
+    description?: string;
+    state: PermissionState;
+    detail?: string;
+}
+export interface PermissionsBackend {
+    list(): Promise<PermissionStatus[]>;
+    request(id: string): Promise<PermissionStatus>;
+}
+export type ModelState = "missing" | "installed" | "downloading" | "verifying" | "error";
+export interface ModelEntry {
+    id: string;
+    label: string;
+    description?: string;
+    sizeBytes?: number;
+    state: ModelState;
+    progress?: number;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+export interface ModelsBackend {
+    list(): Promise<ModelEntry[]>;
+    install(id: string): Promise<void>;
+    /** Optional. The cancel/pause control is shown only when the backend supplies this. */
+    cancel?(id: string): Promise<void>;
+    subscribe?(handler: (entry: ModelEntry) => void): Promise<() => void>;
+}
+export interface LicenseState {
+    status: "none" | "trial" | "active" | "expired" | "invalid";
+    label?: string;
+    detail?: string;
+    tier?: string;
+    validUntil?: string | null;
+}
+export interface LicenseBackend {
+    load(): Promise<LicenseState>;
+    activate?(key: string): Promise<LicenseState>;
+    startTrial?(): Promise<LicenseState>;
+    purchaseUrl?: string;
+    openExternal?: (url: string) => void | Promise<void>;
+}
+export type EligibilityBasis = "individual" | "enterprise";
+/** Full record of one legal acceptance, persisted so version changes can re-prompt. */
+export interface LegalAcceptanceRecord {
+    version: string;
+    documentsHash: string;
+    /** UTC ISO-8601 timestamp (`Date#toISOString`). */
+    acceptedAt: string;
+    eligibilityBasis: EligibilityBasis;
+}
+export interface PersistedOnboardingState {
+    version: 1;
+    currentStep: number;
+    completed: string[];
+    skipped: boolean;
+    /** Legacy boolean, still written for older readers. Prefer `legalAcceptance`. */
+    legalAccepted: boolean;
+    /** Legacy mirror of `legalAcceptance.eligibilityBasis`. */
+    eligibilityBasis?: EligibilityBasis;
+    legalAcceptance?: LegalAcceptanceRecord;
+}
+export interface OnboardingStepContext {
+    state: PersistedOnboardingState;
+    settings: SettingsBackend;
+    setState: (next: Partial<PersistedOnboardingState>) => Promise<void>;
+    permissions?: PermissionsBackend;
+    models?: ModelsBackend;
+    license?: LicenseBackend;
+    /** Readiness reported by steps via `setReady`, keyed by step id. */
+    ready: Readonly<Record<string, boolean>>;
+    /** Reports whether the active step is ready (used by `canContinue`). Stable per step. */
+    setReady: (ready: boolean) => void;
+}
+export interface OnboardingStep {
+    id: string;
+    label: string;
+    title: string;
+    description?: string;
+    skippable?: boolean;
+    /** Continue/Finish stay disabled until this returns true. Default: always allowed. */
+    canContinue?: (context: OnboardingStepContext) => boolean;
+    /** Shown beside the disabled Continue/Finish button. */
+    blockedHint?: string;
+    render: (context: OnboardingStepContext) => ReactNode;
+}
+export interface LegalStepConfig extends Omit<LegalGateProps, "variant" | "onAgree" | "onQuit"> {
+    onQuit?: () => void;
+}
+export interface OnboardingProps {
+    settings: SettingsBackend;
+    legal: LegalStepConfig;
+    /** App-specific steps are appended after built-in steps, in supplied order. */
+    steps?: readonly OnboardingStep[];
+    permissions?: PermissionsBackend;
+    models?: ModelsBackend;
+    license?: LicenseBackend;
+    onComplete: () => void | Promise<void>;
+    onSkip?: () => void | Promise<void>;
+    className?: string;
+    /** Version the user must have accepted. A different (or missing) stored version re-prompts with `variant: "re-acceptance"`. */
+    requiredVersion?: string;
+    /** Custom acceptance check; takes precedence over `requiredVersion`. */
+    isAccepted?: (state: PersistedOnboardingState) => boolean;
+    /** Hash of the legal documents recorded with the acceptance. Default: hash of document titles and URLs. */
+    documentsHash?: string;
+    /** Runs (and is awaited) before the legal gate is shown, e.g. to resize or reveal the window. */
+    beforeLegalGate?: () => void | Promise<void>;
+    /** Require at least one downloaded model before Continue/Finish on the models step. Default false. */
+    requireModel?: boolean;
+    /** Start downloading the first missing model when the models step opens. Default false. */
+    autoStartDownload?: boolean;
+    /** App copy shown at the top of the models step. */
+    modelsIntro?: ReactNode;
+    /** Show "Set up later". Default true. */
+    allowSkip?: boolean;
+    /** Optional titlebar content rendered in a strip along the top. */
+    titlebar?: ReactNode;
+    /** Render a `data-tauri-drag-region` strip at the top. Default false. */
+    dragRegion?: boolean;
+}
+export type { LegalGateDocument, LegalGateTheme };

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui.d.ts

@@ -0,0 +1 @@
+export declare const cx: (...parts: Array<string | false | null | undefined>) => string;

package/dist/ui.js

@@ -0,0 +1 @@
+export const cx = (...parts) => parts.filter(Boolean).join(" ");

package/onboarding.css

@@ -0,0 +1,41 @@
+/* @rightkit/onboarding — uses app-shell tokens and legal-ui's locked light gate. */
+.rk-onboarding { position: relative; min-height: 100vh; display: grid; grid-template-columns: 220px minmax(0, 1fr); background: var(--rk-plane, #fffcf5); color: var(--rk-ink, #231f1a); font: 13px/1.45 -apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif; }
+.rk-onboarding *, .rk-onboarding *::before, .rk-onboarding *::after { box-sizing: border-box; }
+.rk-onboarding__rail { display: flex; flex-direction: column; gap: 22px; padding: 28px 14px; background: var(--rk-chrome, #eee9df); border-right: .5px solid var(--rk-hairline, rgba(35,31,26,.11)); }
+.rk-onboarding__brand { padding: 0 10px; font-size: 19px; font-weight: 650; letter-spacing: -.02em; }
+.rk-onboarding__rail nav { display: grid; gap: 3px; }
+.rk-onboarding__step { display: flex; align-items: center; gap: 10px; width: 100%; padding: 9px 10px; border: 0; border-radius: 8px; background: transparent; color: var(--rk-ink-2, #6b655c); font: inherit; text-align: left; cursor: pointer; }
+.rk-onboarding__step span { display: grid; place-items: center; width: 20px; height: 20px; border: 1px solid var(--rk-line-strong, rgba(35,31,26,.18)); border-radius: 50%; font-size: 11px; }
+.rk-onboarding__step:hover { background: var(--rk-fill, rgba(35,31,26,.05)); color: var(--rk-ink); }
+.rk-onboarding__step.is-active { background: var(--rk-sel, rgba(35,31,26,.06)); color: var(--rk-ink); font-weight: 600; }
+.rk-onboarding__step.is-done span { border-color: var(--rk-ok, #1e7f3c); color: var(--rk-ok, #1e7f3c); }
+.rk-onboarding__main { display: flex; flex-direction: column; min-width: 0; max-width: 840px; width: 100%; padding: 64px clamp(24px, 7vw, 88px) 32px; }
+.rk-onboarding__main header { max-width: 620px; }
+.rk-onboarding__eyebrow { margin: 0 0 8px; color: var(--rk-accent, #7040c4); font-size: 12px; font-weight: 650; letter-spacing: .08em; text-transform: uppercase; }
+.rk-onboarding__main h1 { margin: 0; font-size: clamp(24px, 4vw, 34px); line-height: 1.1; letter-spacing: -.025em; }
+.rk-onboarding__description { margin: 10px 0 0; color: var(--rk-ink-2, #6b655c); font-size: 15px; max-width: 58ch; }
+.rk-onboarding__content { flex: 1; padding: 30px 0; }
+.rk-onboarding__card { display: grid; gap: 2px; max-width: 680px; padding: 6px 0; }
+.rk-onboarding__card > p { color: var(--rk-ink-2, #6b655c); }
+.rk-onboarding__row { display: flex; align-items: center; justify-content: space-between; gap: 20px; padding: 16px 0; border-bottom: .5px solid var(--rk-hairline, rgba(35,31,26,.11)); }
+.rk-onboarding__row:last-child { border-bottom: 0; }
+.rk-onboarding__row p { margin: 3px 0 0; color: var(--rk-ink-2, #6b655c); font-size: 12.5px; }
+.rk-onboarding__row-actions { display: flex; align-items: center; justify-content: flex-end; gap: 8px; flex-wrap: wrap; flex: none; }
+.rk-onboarding__grow { min-width: 0; flex: 1; }
+.rk-onboarding__muted { color: var(--rk-ink-2, #6b655c); }
+.rk-onboarding__error { color: var(--rk-bad, #c4001a); }
+.rk-onboarding__state { color: var(--rk-ink-2, #6b655c); text-transform: capitalize; }
+.rk-onboarding__progress { height: 6px; margin-top: 8px; border-radius: 99px; background: var(--rk-fill-3, rgba(35,31,26,.13)); overflow: hidden; }
+.rk-onboarding__progress i { display: block; height: 100%; background: var(--rk-accent, #7040c4); }
+.rk-onboarding__license-state { display: flex; align-items: center; gap: 10px; margin: 8px 0 18px; }
+.rk-onboarding__license-state small { color: var(--rk-ink-2, #6b655c); }
+.rk-onboarding__form { display: flex; gap: 8px; margin-bottom: 14px; }
+.rk-onboarding__form .rk-input { flex: 1; }
+.rk-onboarding footer { display: flex; align-items: center; gap: 8px; padding-top: 16px; border-top: .5px solid var(--rk-hairline, rgba(35,31,26,.11)); }
+.rk-onboarding footer span { flex: 1; }
+.rk-onboarding--legal { display: block; }
+@media (max-width: 640px) { .rk-onboarding { grid-template-columns: 1fr; } .rk-onboarding__rail { padding: 18px 12px; border-right: 0; border-bottom: .5px solid var(--rk-hairline, rgba(35,31,26,.11)); } .rk-onboarding__rail nav { grid-template-columns: repeat(2, minmax(0, 1fr)); } .rk-onboarding__main { padding: 34px 20px 24px; } .rk-onboarding__row { align-items: flex-start; flex-direction: column; gap: 10px; } .rk-onboarding__row-actions { justify-content: flex-start; } }
+/* Optional window chrome strip (titlebar slot / data-tauri-drag-region). Height is app-tunable. */
+.rk-onboarding__titlebar { position: absolute; inset: 0 0 auto 0; z-index: 2; display: flex; align-items: center; height: var(--rk-onboarding-titlebar-h, 32px); padding: 0 12px; }
+.rk-onboarding__hint { color: var(--rk-ink-2, #6b655c); font-size: 12px; text-align: right; }
+.rk-onboarding__intro { margin-bottom: 12px; color: var(--rk-ink-2, #6b655c); }

package/package.json

@@ -1,6 +1,61 @@
 {
   "name": "@rightkit/onboarding",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "description": "First-run onboarding framework: ordered steps, progress, skip/resume, legal gate first, permissions, model download and licence/trial steps.",
+  "license": "MIT OR Apache-2.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./onboarding.css": "./onboarding.css"
+  },
+  "files": [
+    "dist",
+    "onboarding.css",
+    "README.md",
+    "LICENSE-MIT",
+    "LICENSE-APACHE"
+  ],
+  "sideEffects": [
+    "*.css"
+  ],
+  "peerDependencies": {
+    "@rightkit/app-shell": ">=0.2.0 <1",
+    "@rightkit/legal-ui": ">=0.1.2 <1",
+    "react": ">=18 <20"
+  },
+  "devDependencies": {
+    "@rightkit/app-shell": "0.2.0",
+    "@rightkit/legal-ui": "0.1.2",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.1.0",
+    "@testing-library/user-event": "^14.5.2",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "jsdom": "^25.0.1",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "typescript": "^5.7.0",
+    "vite": "^6.0.0",
+    "vitest": "^2.1.8"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bogusyogi/claude.git",
+    "directory": "tools/rightkit/packages/onboarding"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "pretest": "pnpm --filter \"@rightkit/onboarding^...\" run build",
+    "test": "vitest run"
+  }
 }