@pikku/vite 0.0.0-stage → 0.12.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 - present Yasser Fadl and Pikku contributors
+
+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,23 @@
-# Temporary Holding Version
+# @pikku/vite
 
-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.
+The Vite plugins a Pikku frontend needs, behind one line.
+
+```ts
+// vite.config.ts
+import { pikkuVite } from '@pikku/vite'
+
+export default defineConfig({
+  plugins: [tanstackStart(), pikkuVite(), react()],
+})
+```
+
+`pikkuVite()` reads `pikku.config.json` and applies:
+
+- `testIds()` — adds `data-testid` anchors to JSX for tests and scenarios. With
+  `PIKKUSTUDIO_CHANGES_PANEL=true` it also adds the source anchors Pikku Studio's
+  changes panel uses.
+- `crossSiteSession({ envFile })` from `@pikku/better-auth/vite` — in dev only, and only when
+  the project has Better Auth (its generated `auth/auth.gen.ts` exists). `envFile` is
+  `clientFiles.envFile`.
+
+`testIds()` is also exported for apps that want it alone.

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { pikkuVite } from './pikku-vite.js';
+export type { PikkuViteOptions } from './pikku-vite.js';
+export { testIds } from './test-ids.js';
+export { default as injectTestIds } from './inject-testids.js';
+export { readPikkuViteProject, findPikkuConfig } from './pikku-config.js';
+export type { PikkuViteProject } from './pikku-config.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { pikkuVite } from './pikku-vite.js';
+export { testIds } from './test-ids.js';
+export { default as injectTestIds } from './inject-testids.js';
+export { readPikkuViteProject, findPikkuConfig } from './pikku-config.js';

package/dist/inject-testids.d.ts

@@ -0,0 +1,21 @@
+import type { PluginObj, types as BabelTypes } from '@babel/core';
+export interface InjectTestIdsOptions {
+    /**
+     * Stamp `data-cloud-src="src/routes/app.orders.tsx:42"` beside every testid.
+     *
+     * Off unless cloud turns it on for the build, because this writes the app's
+     * own source layout into markup an end user can read in view-source. It is
+     * also the expensive half of the changes panel: one attribute per addressable
+     * element, where the panel's own code is one chunk.
+     *
+     * The path is interned per module — one string constant the elements in that
+     * file concatenate their line onto — so a file with forty controls ships its
+     * path once rather than forty times.
+     */
+    sourceAnchors?: boolean;
+    /** Repo root the stamped paths are relative to. Defaults to the build's cwd. */
+    root?: string;
+}
+export default function injectTestIds({ types: t }: {
+    types: typeof BabelTypes;
+}, options?: InjectTestIdsOptions): PluginObj;

package/dist/inject-testids.js

@@ -0,0 +1,302 @@
+import path from 'node:path';
+/**
+ * Stamp the addresses browser scenarios use, at compile time.
+ *
+ * Two rules, because a scenario needs to name a control AND, when the same control appears
+ * twice on screen, say which one:
+ *
+ * - **A control** gets `data-testid` = its i18n MESSAGE KEY. Every other address the app
+ *   already has is something it is free to change without meaning to: role+accessible-name
+ *   reads the RENDERED COPY, which here is a paraglide message, so a scenario written
+ *   against it is really asserting a translated string and breaks on a reworded button or a
+ *   locale switch. A CSS selector breaks on a redesign. Message TEXT is copy and changes
+ *   freely; the message KEY is the control's meaning, and only changes when the control's
+ *   meaning does — at which point a scenario naming the old one SHOULD fail.
+ * - **A component's root element** gets `data-testid` = its component name, kebab-cased.
+ *   Keys are NOT unique — `m.common__save()` is meant to be reused — so the id alone is
+ *   ambiguous whenever two forms are open at once. That is not a flaw to design out: this
+ *   app's own console steps already handle testids matching several nodes by filtering
+ *   (`addon-console.steps.ts`), and pikku's TestIdSelector has `within`/`containing` for
+ *   exactly this. Scoping only works if the containers are addressable too, which is what
+ *   this second rule provides — `clicks common__save within entry-form`.
+ *
+ * Deriving both removes the discipline problem rather than policing it: nothing has to be
+ * added to a component, and the ids are identical on every build.
+ */
+/** The shadcn controls, the router's link and the native elements, by tag. */
+const INTERACTIVE = new Set([
+    'Button',
+    'Link',
+    'Input',
+    'InputOTP',
+    'Textarea',
+    'Checkbox',
+    'Switch',
+    'Slider',
+    'Toggle',
+    'ToggleGroupItem',
+    'RadioGroupItem',
+    'SelectTrigger',
+    'SelectItem',
+    'DropdownMenuItem',
+    'DropdownMenuCheckboxItem',
+    'DropdownMenuRadioItem',
+    'TabsTrigger',
+    'AccordionTrigger',
+    'CommandItem',
+    'button',
+    'a',
+    'input',
+    'textarea',
+    'select',
+]);
+/** The elements whose text names the control beside them: `<Label htmlFor="email">`. */
+const LABELS = new Set(['Label', 'FieldLabel', 'FormLabel', 'label']);
+/**
+ * Where a control's meaning is written, most specific first.
+ *
+ * `aria-label` carries it for the icon-only buttons with no visible text — the same
+ * attribute a screen reader needs, so a control this cannot address is usually one a screen
+ * reader cannot announce either.
+ */
+const LABEL_ATTRIBUTES = ['label', 'aria-label', 'placeholder', 'title'];
+const kebab = (name) => name
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
+    .toLowerCase();
+const isInteractive = (tag) => !!tag && INTERACTIVE.has(tag);
+const tagName = (node) => {
+    if (node.type === 'JSXIdentifier')
+        return node.name;
+    if (node.type === 'JSXMemberExpression') {
+        const object = node.object;
+        if (object.type !== 'JSXIdentifier')
+            return null;
+        return `${object.name}.${node.property.name}`;
+    }
+    return null;
+};
+/**
+ * The paraglide message key behind an expression, e.g. `m.entry__save_label()` → the key.
+ *
+ * Searches rather than matching one shape, because a label is as often `cond ? m.a() : m.b()`
+ * as a bare call. The FIRST key wins: across a conditional the branches are one control
+ * saying two things, and an id that changed with state could not be addressed at all.
+ */
+function messageKey(node) {
+    if (!node)
+        return null;
+    if (node.type === 'CallExpression') {
+        const callee = node.callee;
+        if (callee.type === 'MemberExpression' &&
+            callee.object.type === 'Identifier' &&
+            callee.object.name === 'm' &&
+            callee.property.type === 'Identifier') {
+            return callee.property.name;
+        }
+    }
+    const nested = [];
+    if (node.type === 'JSXExpressionContainer')
+        nested.push(node.expression);
+    if (node.type === 'ConditionalExpression')
+        nested.push(node.consequent, node.alternate);
+    if (node.type === 'LogicalExpression')
+        nested.push(node.left, node.right);
+    if (node.type === 'TemplateLiteral')
+        nested.push(...node.expressions);
+    if (node.type === 'CallExpression')
+        nested.push(...node.arguments);
+    for (const child of nested) {
+        const key = messageKey(child);
+        if (key)
+            return key;
+    }
+    return null;
+}
+/** A literal `name`/`id` — the stable identity a control has when its label is dynamic. */
+function literalIdentity(attributes) {
+    return (literalAttribute(attributes, 'name') ?? literalAttribute(attributes, 'id'));
+}
+function literalAttribute(attributes, wanted) {
+    for (const attribute of attributes) {
+        if (attribute.type !== 'JSXAttribute')
+            continue;
+        const attributeName = attribute.name.type === 'JSXIdentifier' ? attribute.name.name : null;
+        if (attributeName !== wanted)
+            continue;
+        if (attribute.value?.type === 'StringLiteral')
+            return attribute.value.value;
+    }
+    return null;
+}
+/**
+ * The message key of the label that names this control from beside it, as shadcn forms do:
+ * `<Label htmlFor="email">{m.common__email()}</Label>` next to `<Input id="email" />`, in the
+ * same parent. A label pointing at a different id belongs to a different control.
+ */
+function siblingLabelKey(element) {
+    const parent = element.parentPath.parentPath?.node;
+    if (parent?.type !== 'JSXElement')
+        return null;
+    const id = literalAttribute(element.node.attributes, 'id');
+    for (const child of parent.children) {
+        if (child.type !== 'JSXElement')
+            continue;
+        const label = child.openingElement;
+        if (!LABELS.has(tagName(label.name) ?? ''))
+            continue;
+        const target = literalAttribute(label.attributes, 'htmlFor');
+        if (target && id && target !== id)
+            continue;
+        for (const text of child.children) {
+            const key = messageKey(text);
+            if (key)
+                return key;
+        }
+    }
+    return null;
+}
+export default function injectTestIds({ types: t }, options = {}) {
+    const anchors = options.sourceAnchors === true;
+    const root = options.root ?? process.cwd();
+    let anchorIdentifier = null;
+    let anchorPath = null;
+    let anchorUsed = false;
+    const attributeName = (attribute) => attribute.type === 'JSXAttribute' && attribute.name.type === 'JSXIdentifier'
+        ? attribute.name.name
+        : null;
+    /**
+     * Whether this element is already spoken for. A hand-written id always wins — it is how a
+     * list row carries the id of the record it shows, which no static rule could derive. A
+     * spread may carry one, and merging into it would need a runtime helper for a case that is
+     * already addressable, so leave those to the author too.
+     */
+    const claimed = (element) => element.attributes.some((attribute) => attributeName(attribute) === 'data-testid' ||
+        attribute.type === 'JSXSpreadAttribute');
+    const stamp = (element, value) => {
+        element.attributes.push(t.jsxAttribute(t.jsxIdentifier('data-testid'), t.stringLiteral(value)));
+    };
+    /**
+     * Anchors go on elements that are ALREADY claimed by a hand-written testid too
+     * — knowing an element's name and knowing where its JSX lives are different
+     * questions, and the author answering the first does not answer the second.
+     */
+    const anchor = (element) => {
+        if (!anchors || !anchorIdentifier)
+            return;
+        const line = element.loc?.start.line;
+        if (!line)
+            return;
+        if (element.attributes.some((attribute) => attributeName(attribute) === 'data-cloud-src')) {
+            return;
+        }
+        anchorUsed = true;
+        element.attributes.push(t.jsxAttribute(t.jsxIdentifier('data-cloud-src'), t.jsxExpressionContainer(t.binaryExpression('+', t.cloneNode(anchorIdentifier), t.stringLiteral(`:${line}`)))));
+    };
+    /** A component is a PascalCase function — the same rule React itself uses to tell them apart. */
+    const componentName = (path) => {
+        const node = path.node;
+        if (node.type === 'FunctionDeclaration' && node.id) {
+            return /^[A-Z]/.test(node.id.name) ? node.id.name : null;
+        }
+        const parent = path.parent;
+        if (parent.type === 'VariableDeclarator' &&
+            parent.id.type === 'Identifier') {
+            return /^[A-Z]/.test(parent.id.name) ? parent.id.name : null;
+        }
+        return null;
+    };
+    return {
+        name: 'pikku-inject-testids',
+        visitor: {
+            Program: {
+                enter(program, state) {
+                    anchorIdentifier = null;
+                    anchorPath = null;
+                    anchorUsed = false;
+                    if (!anchors || !state.filename)
+                        return;
+                    anchorPath = path
+                        .relative(root, state.filename)
+                        .split(path.sep)
+                        .join('/');
+                    anchorIdentifier = program.scope.generateUidIdentifier('cloudSrc');
+                },
+                exit(program) {
+                    if (!anchorUsed || !anchorIdentifier || !anchorPath)
+                        return;
+                    program.unshiftContainer('body', t.variableDeclaration('const', [
+                        t.variableDeclarator(anchorIdentifier, t.stringLiteral(anchorPath)),
+                    ]));
+                },
+            },
+            JSXOpeningElement(path) {
+                if (!isInteractive(tagName(path.node.name)))
+                    return;
+                anchor(path.node);
+                if (claimed(path.node))
+                    return;
+                let key = null;
+                for (const wanted of LABEL_ATTRIBUTES) {
+                    for (const attribute of path.node.attributes) {
+                        if (attributeName(attribute) !== wanted ||
+                            attribute.type !== 'JSXAttribute')
+                            continue;
+                        key = messageKey(attribute.value);
+                        if (key)
+                            break;
+                    }
+                    if (key)
+                        break;
+                }
+                // A button says what it does in its children rather than a label prop.
+                if (!key && path.parentPath.node.type === 'JSXElement') {
+                    for (const child of path.parentPath.node.children) {
+                        key = messageKey(child);
+                        if (key)
+                            break;
+                    }
+                }
+                key ??= siblingLabelKey(path);
+                key ??= literalIdentity(path.node.attributes);
+                // No key, no id — DELIBERATELY. The alternative is a positional fallback
+                // (`today-button-3`) that shifts the moment a control is added above it, turning
+                // every scenario using it into a flake. A control with no message key and no `name`
+                // has no stable identity to expose, and the fix belongs upstream: give it an
+                // `aria-label`, which it needs for a screen reader anyway.
+                if (key)
+                    stamp(path.node, key);
+            },
+            Function(path) {
+                const name = componentName(path);
+                if (!name)
+                    return;
+                const id = kebab(name);
+                // Every element this component can RETURN, so a component that renders a loading
+                // state and a loaded one is addressable in both. Returns inside a nested function
+                // belong to that function (a render prop, a map callback), not to this component.
+                path.traverse({
+                    Function(inner) {
+                        inner.skip();
+                    },
+                    ReturnStatement(statement) {
+                        const returned = statement.node.argument;
+                        if (returned?.type !== 'JSXElement')
+                            return;
+                        anchor(returned.openingElement);
+                        if (claimed(returned.openingElement))
+                            return;
+                        // A component whose root IS a control (a lone `<Select>` wrapped in nothing)
+                        // keeps its OWN key — the more specific address, and there is nothing inside it
+                        // to scope anyway. Without this the container rule would win purely because
+                        // babel reaches the function before its JSX, and the control would be
+                        // addressable only by the name of the component wrapping it.
+                        if (isInteractive(tagName(returned.openingElement.name)))
+                            return;
+                        stamp(returned.openingElement, id);
+                    },
+                });
+            },
+        },
+    };
+}

package/dist/pikku-config.d.ts

@@ -0,0 +1,16 @@
+/** What the Vite plugins need to know about the project, read from `pikku.config.json`. */
+export interface PikkuViteProject {
+    /** Directory holding `pikku.config.json`. */
+    configDir: string;
+    /** True when the project declares Better Auth, i.e. its generated auth wiring exists. */
+    betterAuth: boolean;
+    /** Absolute path of the generated `env.gen.ts` exporting `apiUrl()`, when configured. */
+    envFile?: string;
+}
+/** Walk up from `from` to the nearest `pikku.config.json`. */
+export declare const findPikkuConfig: (from: string) => string | undefined;
+/**
+ * Read the project's `pikku.config.json`, found from `from` upward. A project
+ * with none gets the defaults: test ids only.
+ */
+export declare const readPikkuViteProject: (from?: string) => PikkuViteProject | undefined;

package/dist/pikku-config.js

@@ -0,0 +1,46 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+/** Walk up from `from` to the nearest `pikku.config.json`. */
+export const findPikkuConfig = (from) => {
+    let dir = resolve(from);
+    for (;;) {
+        const candidate = join(dir, 'pikku.config.json');
+        if (existsSync(candidate))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+};
+const absolute = (base, path) => isAbsolute(path) ? path : join(base, path);
+/**
+ * Where the CLI writes the Better Auth wiring: `scaffold.pikkuDir`, or `scaffold/`
+ * beside the first source directory. Its presence is the project saying it uses
+ * Better Auth, the same signal `pikku all` acts on.
+ */
+const authWiringFile = (config, configDir) => {
+    const rootDir = absolute(configDir, config.rootDir ?? '.');
+    const scaffoldDir = config.scaffold?.pikkuDir
+        ? absolute(rootDir, config.scaffold.pikkuDir)
+        : absolute(rootDir, join(config.srcDirectories?.[0] ?? 'src', 'scaffold'));
+    return join(scaffoldDir, 'auth', 'auth.gen.ts');
+};
+/**
+ * Read the project's `pikku.config.json`, found from `from` upward. A project
+ * with none gets the defaults: test ids only.
+ */
+export const readPikkuViteProject = (from = process.cwd()) => {
+    const configPath = findPikkuConfig(from);
+    if (!configPath)
+        return undefined;
+    const configDir = dirname(configPath);
+    const config = JSON.parse(readFileSync(configPath, 'utf8'));
+    return {
+        configDir,
+        betterAuth: existsSync(authWiringFile(config, configDir)),
+        envFile: config.clientFiles?.envFile
+            ? absolute(configDir, config.clientFiles.envFile)
+            : undefined,
+    };
+};

package/dist/pikku-vite.d.ts

@@ -0,0 +1,17 @@
+import type { PluginOption } from 'vite';
+export interface PikkuViteOptions {
+    /** Where to start looking for `pikku.config.json`. Defaults to the directory vite runs in. */
+    from?: string;
+}
+/**
+ * The Pikku plugins a frontend needs, chosen from `pikku.config.json`:
+ *
+ * - `testIds()` always — scenarios drive built apps, not only the dev server.
+ * - the Better Auth cross-site session relay when the project declares Better
+ *   Auth (dev server only; see `@pikku/better-auth/vite`).
+ *
+ * ```ts
+ * export default defineConfig({ plugins: [tanstackStart(), pikkuVite(), react()] })
+ * ```
+ */
+export declare const pikkuVite: (options?: PikkuViteOptions) => PluginOption[];

package/dist/pikku-vite.js

@@ -0,0 +1,22 @@
+import { readPikkuViteProject } from './pikku-config.js';
+import { testIds } from './test-ids.js';
+/**
+ * The Pikku plugins a frontend needs, chosen from `pikku.config.json`:
+ *
+ * - `testIds()` always — scenarios drive built apps, not only the dev server.
+ * - the Better Auth cross-site session relay when the project declares Better
+ *   Auth (dev server only; see `@pikku/better-auth/vite`).
+ *
+ * ```ts
+ * export default defineConfig({ plugins: [tanstackStart(), pikkuVite(), react()] })
+ * ```
+ */
+export const pikkuVite = (options = {}) => {
+    const project = readPikkuViteProject(options.from);
+    const plugins = [testIds()];
+    if (project?.betterAuth) {
+        // Loaded on demand: a project without Better Auth need not have it installed.
+        plugins.push(import('@pikku/better-auth/vite').then(({ crossSiteSession }) => crossSiteSession({ envFile: project.envFile })));
+    }
+    return plugins;
+};

package/dist/test-ids.d.ts

@@ -0,0 +1,19 @@
+import type { Plugin } from 'vite';
+/**
+ * Run the testid stamper over the app's JSX.
+ *
+ * A standalone pre-transform rather than a `babel` option on `@vitejs/plugin-react`, which
+ * mirrors how `apps/console` runs its `data-om` plugin and for the same reason:
+ * plugin-react@6 is the rolldown/oxc build and has NO babel option, so a transform hung off
+ * that option stops running on the version bump — silently, since the app still builds and
+ * only the scenarios notice. Owning the babel pass costs one extra parse of the app's own
+ * source in exchange for surviving that.
+ *
+ * NOT `apply: 'serve'`: scenarios drive the built sandbox app as well as the dev server, so
+ * a dev-only stamp would leave every deployed app unaddressable.
+ *
+ * The source anchors ride along on the same parse, but only when cloud asks
+ * for them — they put the app's file layout in view-source, and the panel that
+ * reads them is gated on the same flag.
+ */
+export declare function testIds(): Plugin;

package/dist/test-ids.js

@@ -0,0 +1,43 @@
+import * as babel from '@babel/core';
+import injectTestIds from './inject-testids.js';
+const JSX_FILE = /\.[jt]sx$/;
+/**
+ * Run the testid stamper over the app's JSX.
+ *
+ * A standalone pre-transform rather than a `babel` option on `@vitejs/plugin-react`, which
+ * mirrors how `apps/console` runs its `data-om` plugin and for the same reason:
+ * plugin-react@6 is the rolldown/oxc build and has NO babel option, so a transform hung off
+ * that option stops running on the version bump — silently, since the app still builds and
+ * only the scenarios notice. Owning the babel pass costs one extra parse of the app's own
+ * source in exchange for surviving that.
+ *
+ * NOT `apply: 'serve'`: scenarios drive the built sandbox app as well as the dev server, so
+ * a dev-only stamp would leave every deployed app unaddressable.
+ *
+ * The source anchors ride along on the same parse, but only when cloud asks
+ * for them — they put the app's file layout in view-source, and the panel that
+ * reads them is gated on the same flag.
+ */
+export function testIds() {
+    const sourceAnchors = process.env.PIKKUSTUDIO_CHANGES_PANEL === 'true';
+    return {
+        name: 'pikku:testids',
+        enforce: 'pre',
+        async transform(code, id) {
+            const file = id.split('?')[0];
+            if (!file || !JSX_FILE.test(file) || file.includes('/node_modules/'))
+                return null;
+            const result = await babel.transformAsync(code, {
+                filename: file,
+                babelrc: false,
+                configFile: false,
+                sourceMaps: true,
+                parserOpts: { plugins: ['jsx', 'typescript'] },
+                plugins: [[injectTestIds, { sourceAnchors }]],
+            });
+            if (!result?.code)
+                return null;
+            return { code: result.code, map: result.map };
+        },
+    };
+}

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "@pikku/vite",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.12.1",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pikkujs/pikku.git",
+    "directory": "packages/frontend/vite"
+  },
+  "description": "Vite plugins for Pikku frontends — scenario test ids and the Better Auth cross-site session relay, applied from pikku.config.json",
+  "author": "yasser.fadl@gmail.com",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.tsbuildinfo"
+  ],
+  "scripts": {
+    "tsc": "tsc && tsc -p tsconfig.tests.json",
+    "build": "bun run clean && tsc -b",
+    "test": "bun test --timeout 120000 src",
+    "prepublishOnly": "bun run build",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo"
+  },
+  "dependencies": {
+    "@babel/core": "^7.26.0"
+  },
+  "peerDependencies": {
+    "@pikku/better-auth": "^0.12.61",
+    "vite": "^5 || ^6 || ^7"
+  },
+  "peerDependenciesMeta": {
+    "@pikku/better-auth": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@pikku/better-auth": "workspace:*",
+    "@types/babel__core": "^7.20.5",
+    "vite": "^7.0.0"
+  }
+}