@vibesdotdev/kit 0.0.0-stage → 1.0.0-rc.3

package/LICENSE

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2026 VIBES DEV LLC
+
+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,98 @@
-# Temporary Holding Version
+# `@vibesdotdev/kit`
 
-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.
+VibesKit is a SvelteKit toolkit for reusable UI, typed server wrappers, forms,
+pagination, data tables, themes, and API explorers.
+
+This repository is the public Kit repository. It is separate from the Vibes
+Framework repository. Kit does not own application identity, persistence,
+billing, or deployment policy. Your application supplies those services.
+
+Server helpers consume Framework contracts through exact package dependencies:
+`@vibesdotdev/cache@0.0.1`, `@vibesdotdev/logging@0.0.3`,
+`@vibesdotdev/runtime@0.0.3`, `@vibesdotdev/scope@0.0.1`, and
+`@vibesdotdev/shared@0.1.2`. These packages are coordinated Framework releases;
+Kit does not copy their runtime, cache, scope, logging, or shared contracts.
+
+UI preferences (shell style, theme preset, mode, sidebar and section state)
+persist through the runtime you compose, not a browser storage global: Kit
+resolves the runtime's browser host as its preference storage, and an absent,
+blocked or malformed value reads as the preference's declared default. With no
+runtime, cookies and defaults still work. API documentation contact origins
+come from Kit config (`docsContactOrigin`): a composed `kit` manifest entry,
+else the environment catalog for the runtime's tier.
+
+## Install
+
+```sh
+bun add @vibesdotdev/kit
+bun add @sveltejs/kit svelte tailwindcss zod
+```
+
+Import the stylesheet once:
+
+```ts
+import '@vibesdotdev/kit/styles.css';
+```
+
+## Use a component
+
+```svelte
+<script lang="ts">
+	import { Button } from '@vibesdotdev/kit/components/ui/button';
+	import { Card } from '@vibesdotdev/kit/components/ui/card';
+</script>
+
+<main aria-labelledby="title">
+	<h1 id="title">Settings</h1>
+	<Card>
+		<Button type="button">Save</Button>
+	</Card>
+</main>
+```
+
+Use semantic HTML around Kit components. Give form controls labels. Give
+tables a caption and header scopes.
+
+## Use a server wrapper
+
+```ts
+// src/routes/api/items/+server.ts
+import { z } from 'zod';
+import { vibesPOST } from '@vibesdotdev/kit/server';
+
+const itemInput = z.object({ name: z.string().trim().min(1) });
+
+export const POST = vibesPOST({ validation: { body: itemInput } }, async (_event, context) => ({
+	item: await saveItem(context.validated.body)
+}));
+```
+
+The wrapper validates the body before it calls your application service. Kit
+does not create the service or the database.
+
+## Explore the package
+
+The repository contains a runnable SvelteKit showcase:
+
+```sh
+bun install --frozen-lockfile
+bun run dev
+```
+
+The showcase includes the component gallery and server/client documentation.
+The [documentation](./docs/README.md) includes a reading-list application and
+a status-dashboard application.
+
+## Verify a release
+
+```sh
+bun run check
+bun run test:unit -- --run
+bun run build
+bun run prepack
+bun run verify:exports
+npm pack --dry-run
+```
+
+The package exports are explicit. Import from the documented subpaths. Do not
+import files below `src/` from an installed package.

package/dist/layout/components/LayoutLoader.svelte

@@ -0,0 +1,80 @@
+<script lang="ts">import { untrack } from "svelte";
+import { settle } from "../../lib/attempt.js";
+let { defaultSidebarLeftOpen, state: suppliedState, capture, onFailure } = $props();
+let activeState = $state(null);
+let failed = $state(false);
+const reported = new Set();
+function report(result) {
+	failed = true;
+	const key = `${result.code}:${result.reason}`;
+	if (reported.has(key)) return;
+	reported.add(key);
+	const observation = {
+		status: "refused",
+		code: result.code,
+		reason: result.reason
+	};
+	Object.defineProperty(observation, "cause", { value: result.cause });
+	onFailure?.(observation);
+}
+$effect(() => {
+	const supplied = suppliedState;
+	const pending = supplied ? undefined : capture;
+	let live = true;
+	let owned;
+	untrack(() => {
+		const options = { defaultSidebarLeftOpen };
+		failed = false;
+		activeState = null;
+		if (supplied) {
+			supplied.init(options);
+			activeState = supplied;
+		} else if (pending) {
+			void settle(async () => {
+				const result = await pending;
+				if (!live) {
+					if (result.ok) result.adapter.dispose();
+					return;
+				}
+				if (!result.ok) {
+					report(result.failure);
+					return;
+				}
+				owned = result.adapter;
+				owned.layoutState.init(options);
+				activeState = owned.layoutState;
+			}).then((completed) => {
+				if (completed.ok) return;
+				if (live) report({
+					status: "refused",
+					code: "UNAVAILABLE",
+					reason: "layout-storage-blocked",
+					cause: completed.error
+				});
+			});
+		} else {
+			report({
+				status: "refused",
+				code: "UNAVAILABLE",
+				reason: "layout-adapter-uncaptured"
+			});
+		}
+	});
+	return () => {
+		live = false;
+		owned?.dispose();
+	};
+});
+$effect(() => {
+	const read = activeState?.lastReadResult;
+	const write = activeState?.lastWriteResult;
+	untrack(() => {
+		if (read?.status === "refused") report(read);
+		if (write?.status === "refused") report(write);
+	});
+});
+</script>
+
+{#if failed}
+	<p role="alert">Layout preferences are unavailable.</p>
+{/if}

package/dist/layout/components/LayoutLoader.svelte.d.ts

@@ -0,0 +1,13 @@
+import type { LayoutFailure } from '../runtime.ts';
+import type { LayoutState, LayoutStateInitOptions } from '../state.svelte.ts';
+import type { LayoutCaptureResult } from '../runtime-compat.svelte.ts';
+interface Props extends LayoutStateInitOptions {
+    /** Explicit state bypasses Runtime capture and remains caller-owned. */
+    state?: LayoutState;
+    /** Created by the opt-in capture helper during the caller's initialization. */
+    capture?: Promise<LayoutCaptureResult>;
+    onFailure?: (failure: LayoutFailure) => void;
+}
+declare const LayoutLoader: import("svelte").Component<Props, {}, "">;
+type LayoutLoader = ReturnType<typeof LayoutLoader>;
+export default LayoutLoader;

package/dist/layout/components/SidebarPanel.svelte

@@ -0,0 +1,81 @@
+<script lang="ts">import { Button } from "../../lib/components/ui/button/index.js";
+import * as ContextMenu from "../../lib/components/ui/context-menu/index.js";
+let { title, icon: Icon, onClose, content, footer, headerActions, menuContent } = $props();
+</script>
+
+<div class="sidebar-panel flex h-full w-full flex-col">
+	<div class="sidebar-panel__header">
+		<h3 class="sidebar-panel__title">
+			{#if Icon}<Icon class="mr-2 h-4 w-4" />{/if}
+			{title}
+		</h3>
+		<div class="flex items-center gap-2">
+			{@render headerActions?.()}
+			{#if onClose}
+				<Button size="icon" variant="ghost" class="h-8 w-8" onclick={onClose} aria-label="Close">
+					<svg viewBox="0 0 24 24" class="h-4 w-4" aria-hidden="true"
+						><path
+							d="M18 6L6 18M6 6l12 12"
+							stroke="currentColor"
+							stroke-width="2"
+							stroke-linecap="round"
+						/></svg
+					>
+				</Button>
+			{/if}
+		</div>
+	</div>
+
+	{#if menuContent}
+		<ContextMenu.ContextMenu>
+			<ContextMenu.ContextMenuTrigger class="min-h-0 flex-1">
+				<div class="sidebar-panel__content h-full w-full">
+					{@render content?.()}
+				</div>
+			</ContextMenu.ContextMenuTrigger>
+			<ContextMenu.ContextMenuContent>
+				{@render menuContent?.()}
+			</ContextMenu.ContextMenuContent>
+		</ContextMenu.ContextMenu>
+	{:else}
+		<div class="sidebar-panel__content h-full w-full">
+			{@render content?.()}
+		</div>
+	{/if}
+
+	{#if footer}
+		<div class="sidebar-panel__footer">
+			{@render footer()}
+		</div>
+	{/if}
+</div>
+
+<style>
+	.sidebar-panel__header {
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		border-bottom: 1px solid var(--border, #e5e7eb);
+		padding: 1rem;
+	}
+	.sidebar-panel__title {
+		display: flex;
+		align-items: center;
+		font-size: 1.125rem;
+		font-weight: 600;
+	}
+	.sidebar-panel__content {
+		flex: 1 1 0%;
+		overflow: auto;
+	}
+	.sidebar-panel__footer {
+		margin-top: auto;
+		display: flex;
+		width: 100%;
+		align-items: center;
+		justify-content: flex-end;
+		gap: 0.5rem;
+		border-top: 1px solid var(--border, #e5e7eb);
+		padding: 0.5rem;
+	}
+</style>

package/dist/layout/components/SidebarPanel.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { SidebarPanelProps } from '../types.ts';
+declare const SidebarPanel: import("svelte").Component<SidebarPanelProps, {}, "">;
+type SidebarPanel = ReturnType<typeof SidebarPanel>;
+export default SidebarPanel;

package/dist/layout/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `@vibesdotdev/kit/layout` - theme-agnostic Svelte 5 layout primitives.
+ *
+ * Apps assemble their chrome from the kit's `<AppShell>` plus feature-level
+ * surfaces (sidebar contents, header actions). This package owns the small
+ * shared shell pieces that every app implements identically:
+ *
+ *  - `<SidebarPanel>` - generic header + content + footer + context-menu
+ *    chrome consumed inside an app's sidebar slot. No domain semantics.
+ *  - `createLayoutState(host)` - view-local sidebar state over supplied storage.
+ *  - `layoutState` - uncaptured compatibility name; usable state comes from an adapter.
+ *  - `<LayoutLoader>` - non-visual state initialization driver.
+ *
+ * No theming, branding, or auth lives here. Theming is the consuming app's
+ * concern; auth-aware navigation belongs in `@vibesdotdev/auth/svelte`.
+ */
+export { default as SidebarPanel } from './components/SidebarPanel.svelte';
+export { default as LayoutLoader } from './components/LayoutLoader.svelte';
+export { createLayoutState, layoutState } from './state.svelte.ts';
+export type { LayoutState, LayoutStateInitOptions } from './state.svelte.ts';
+export type { CapturedLayoutAdapter, LayoutCaptureResult } from './runtime-compat.svelte.ts';
+export { readLayoutPreference, writeLayoutPreference } from './runtime.ts';
+export type { LayoutHost, LayoutStorage, LayoutFailure, LayoutFailureReason, LayoutReadResult, LayoutWriteResult } from './runtime.ts';
+export type { SidebarPanelProps } from './types.ts';

package/dist/layout/index.js

@@ -0,0 +1,20 @@
+/**
+ * `@vibesdotdev/kit/layout` - theme-agnostic Svelte 5 layout primitives.
+ *
+ * Apps assemble their chrome from the kit's `<AppShell>` plus feature-level
+ * surfaces (sidebar contents, header actions). This package owns the small
+ * shared shell pieces that every app implements identically:
+ *
+ *  - `<SidebarPanel>` - generic header + content + footer + context-menu
+ *    chrome consumed inside an app's sidebar slot. No domain semantics.
+ *  - `createLayoutState(host)` - view-local sidebar state over supplied storage.
+ *  - `layoutState` - uncaptured compatibility name; usable state comes from an adapter.
+ *  - `<LayoutLoader>` - non-visual state initialization driver.
+ *
+ * No theming, branding, or auth lives here. Theming is the consuming app's
+ * concern; auth-aware navigation belongs in `@vibesdotdev/auth/svelte`.
+ */
+export { default as SidebarPanel } from './components/SidebarPanel.svelte';
+export { default as LayoutLoader } from './components/LayoutLoader.svelte';
+export { createLayoutState, layoutState } from "./state.svelte.js";
+export { readLayoutPreference, writeLayoutPreference } from "./runtime.js";

package/dist/layout/loaders.d.ts

@@ -0,0 +1,20 @@
+/**
+ * SvelteKit `load` helpers for `@vibesdotdev/kit/layout`.
+ *
+ * Exposed under the `./loaders` subpath so SvelteKit keeps any server-only
+ * code out of the browser bundle. Layout state today is purely client-driven
+ * (sidebar collapse persisted to `localStorage`), so the loader is a no-op
+ * that returns an empty payload - kept as the canonical extension point for
+ * future server-seeded layout state (e.g. user-preference sidebar default).
+ */
+import type { ServerLoadEvent } from '@sveltejs/kit';
+export interface LayoutLoaderData {
+    /**
+     * Optional server-seeded default for the left sidebar. When provided,
+     * `<LayoutLoader initialSidebarLeftOpen>` consumes it before localStorage
+     * is read. Today no server seeds this - placeholder for future user
+     * preferences.
+     */
+    defaultSidebarLeftOpen?: boolean;
+}
+export declare function loadLayoutData(_event: ServerLoadEvent): Promise<LayoutLoaderData>;

package/dist/layout/loaders.js

@@ -0,0 +1,12 @@
+/**
+ * SvelteKit `load` helpers for `@vibesdotdev/kit/layout`.
+ *
+ * Exposed under the `./loaders` subpath so SvelteKit keeps any server-only
+ * code out of the browser bundle. Layout state today is purely client-driven
+ * (sidebar collapse persisted to `localStorage`), so the loader is a no-op
+ * that returns an empty payload - kept as the canonical extension point for
+ * future server-seeded layout state (e.g. user-preference sidebar default).
+ */
+export async function loadLayoutData(_event) {
+    return {};
+}

package/dist/layout/runtime-compat.svelte.d.ts

@@ -0,0 +1,17 @@
+import { type LayoutFailure } from './runtime.ts';
+import { type LayoutState } from './state.svelte.ts';
+export interface CapturedLayoutAdapter {
+    readonly layoutState: LayoutState;
+    readStoredSidebarLeftOpen(): boolean | null;
+    writeStoredSidebarLeftOpen(open: boolean): void;
+    dispose(): void;
+}
+export type LayoutCaptureResult = {
+    readonly ok: true;
+    readonly adapter: CapturedLayoutAdapter;
+} | {
+    readonly ok: false;
+    readonly failure: Error & LayoutFailure;
+};
+/** Call during component initialization. No fallback runtime is created or booted. */
+export declare function captureLayoutAdapter(): Promise<LayoutCaptureResult>;

package/dist/layout/runtime-compat.svelte.js

@@ -0,0 +1,138 @@
+import { CapabilityError, getRuntimeBrowserHost, rootIdentityOf } from '@vibesdotdev/kernel';
+import { peekRuntimeSvelteContext } from '@vibesdotdev/surface-sveltekit/svelte/state';
+import { settle, settleNow } from "../lib/attempt.js";
+import { readLayoutPreference, writeLayoutPreference } from "./runtime.js";
+import { createLayoutState } from "./state.svelte.js";
+function capabilityFailure(outcome) {
+    return Object.assign(new CapabilityError('Layout persistence is unavailable.', outcome.code, {
+        reason: outcome.reason,
+        retryable: false,
+        cause: outcome.cause
+    }), outcome);
+}
+function failure(code, reason, cause) {
+    return capabilityFailure({ status: 'refused', code, reason, cause });
+}
+function bindLayoutHost(host, isRootDisposed) {
+    const state = createLayoutState(host);
+    let disposed = false;
+    const assertLive = () => {
+        if (disposed || isRootDisposed()) {
+            state.dispose();
+            throw failure('CANCELLED', 'layout-adapter-disposed');
+        }
+    };
+    const layoutState = {
+        get sidebarLeftOpen() {
+            return state.sidebarLeftOpen;
+        },
+        set sidebarLeftOpen(open) {
+            assertLive();
+            state.sidebarLeftOpen = open;
+        },
+        get initialized() {
+            return state.initialized;
+        },
+        set initialized(value) {
+            assertLive();
+            state.initialized = value;
+        },
+        get lastReadResult() {
+            return state.lastReadResult;
+        },
+        get lastWriteResult() {
+            return state.lastWriteResult;
+        },
+        init(options) {
+            if (disposed || isRootDisposed())
+                state.dispose();
+            state.init(options);
+        },
+        setSidebarLeftOpen(open) {
+            if (disposed || isRootDisposed())
+                state.dispose();
+            state.setSidebarLeftOpen(open);
+        },
+        toggleSidebarLeft() {
+            if (disposed || isRootDisposed())
+                state.dispose();
+            state.toggleSidebarLeft();
+        },
+        dispose() {
+            disposed = true;
+            state.dispose();
+        }
+    };
+    return {
+        layoutState,
+        readStoredSidebarLeftOpen() {
+            assertLive();
+            const result = readLayoutPreference(host);
+            if (result.status === 'refused')
+                throw capabilityFailure(result);
+            return result.status === 'found' ? result.value : null;
+        },
+        writeStoredSidebarLeftOpen(open) {
+            assertLive();
+            const result = writeLayoutPreference(host, open);
+            if (result.status === 'refused')
+                throw capabilityFailure(result);
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            layoutState.dispose();
+        }
+    };
+}
+/** Call during component initialization. No fallback runtime is created or booted. */
+export async function captureLayoutAdapter() {
+    // Svelte context is available only before the first await.
+    const context = settleNow(() => peekRuntimeSvelteContext());
+    if (!context.ok) {
+        return {
+            ok: false,
+            failure: failure('UNAVAILABLE', 'layout-adapter-uncaptured', context.error)
+        };
+    }
+    const store = context.value;
+    if (!store) {
+        return { ok: false, failure: failure('UNAVAILABLE', 'layout-adapter-uncaptured') };
+    }
+    const loaded = await settle(() => store.load());
+    if (!loaded.ok) {
+        return {
+            ok: false,
+            failure: failure('UNAVAILABLE', 'layout-runtime-unavailable', loaded.error)
+        };
+    }
+    const runtime = loaded.value;
+    if (!rootIdentityOf(runtime)) {
+        return { ok: false, failure: failure('INVALID_INPUT', 'layout-runtime-invalid') };
+    }
+    const isRootEnded = () => runtime.disposed || runtime.lifecycle.phase !== 'live';
+    if (isRootEnded()) {
+        return { ok: false, failure: failure('CANCELLED', 'layout-adapter-disposed') };
+    }
+    const browserHost = await settle(() => getRuntimeBrowserHost(runtime));
+    if (!browserHost.ok) {
+        if (isRootEnded()) {
+            return {
+                ok: false,
+                failure: failure('CANCELLED', 'layout-adapter-disposed', browserHost.error)
+            };
+        }
+        return {
+            ok: false,
+            failure: failure('UNAVAILABLE', 'layout-storage-blocked', browserHost.error)
+        };
+    }
+    if (isRootEnded()) {
+        return { ok: false, failure: failure('CANCELLED', 'layout-adapter-disposed') };
+    }
+    const adapter = settleNow(() => bindLayoutHost(browserHost.value, isRootEnded));
+    return adapter.ok
+        ? { ok: true, adapter: adapter.value }
+        : { ok: false, failure: failure('UNAVAILABLE', 'layout-storage-blocked', adapter.error) };
+}

package/dist/layout/runtime.d.ts

@@ -0,0 +1,37 @@
+export interface LayoutStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+}
+export interface LayoutHost {
+    readonly storage: LayoutStorage;
+}
+export type LayoutFailureReason = 'layout-storage-blocked' | 'layout-preference-invalid' | 'layout-adapter-uncaptured' | 'layout-runtime-unavailable' | 'layout-runtime-invalid' | 'layout-adapter-disposed';
+export interface LayoutFailure {
+    readonly status: 'refused';
+    readonly code: 'UNAVAILABLE' | 'INVALID_INPUT' | 'CANCELLED';
+    readonly reason: LayoutFailureReason;
+    /** Private failure identity for the host's observer; never render it. */
+    readonly cause?: unknown;
+}
+export type LayoutReadResult = {
+    status: 'found';
+    value: boolean;
+} | {
+    status: 'missing';
+} | LayoutFailure;
+export type LayoutWriteResult = {
+    status: 'written';
+} | LayoutFailure;
+/**
+ * Storage key used to persist sidebar collapse state across page reloads.
+ *
+ * Exported so apps can clear or migrate the key during account switches.
+ */
+export declare const SIDEBAR_LEFT_STORAGE_KEY = "vibes:layout:sidebar-left-open";
+export declare function readLayoutPreference(host: LayoutHost): LayoutReadResult;
+export declare function writeLayoutPreference(host: LayoutHost, open: boolean): LayoutWriteResult;
+export declare function uncapturedLayoutFailure(): LayoutFailure;
+/** Use the identically named method on a captured adapter for a bound no-argument read. */
+export declare function readStoredSidebarLeftOpen(): boolean | null;
+/** Use the identically named method on a captured adapter for a bound write. */
+export declare function writeStoredSidebarLeftOpen(_open: boolean): void;

package/dist/layout/runtime.js

@@ -0,0 +1,51 @@
+/** Neutral layout persistence. Hosts supply storage; Kit selects no ambient host. */
+import { settleNow } from "../lib/attempt.js";
+/**
+ * Storage key used to persist sidebar collapse state across page reloads.
+ *
+ * Exported so apps can clear or migrate the key during account switches.
+ */
+export const SIDEBAR_LEFT_STORAGE_KEY = 'vibes:layout:sidebar-left-open';
+function blockedStorage(cause) {
+    const outcome = {
+        status: 'refused',
+        code: 'UNAVAILABLE',
+        reason: 'layout-storage-blocked'
+    };
+    return Object.defineProperty(outcome, 'cause', { value: cause });
+}
+export function readLayoutPreference(host) {
+    const read = settleNow(() => host.storage.getItem(SIDEBAR_LEFT_STORAGE_KEY));
+    if (!read.ok)
+        return blockedStorage(read.error);
+    const value = read.value;
+    if (value === null)
+        return { status: 'missing' };
+    if (value === 'true')
+        return { status: 'found', value: true };
+    if (value === 'false')
+        return { status: 'found', value: false };
+    return { status: 'refused', code: 'INVALID_INPUT', reason: 'layout-preference-invalid' };
+}
+export function writeLayoutPreference(host, open) {
+    if (open !== true && open !== false) {
+        return { status: 'refused', code: 'INVALID_INPUT', reason: 'layout-preference-invalid' };
+    }
+    const write = settleNow(() => host.storage.setItem(SIDEBAR_LEFT_STORAGE_KEY, open ? 'true' : 'false'));
+    return write.ok ? { status: 'written' } : blockedStorage(write.error);
+}
+export function uncapturedLayoutFailure() {
+    return Object.freeze({
+        status: 'refused',
+        code: 'UNAVAILABLE',
+        reason: 'layout-adapter-uncaptured'
+    });
+}
+/** Use the identically named method on a captured adapter for a bound no-argument read. */
+export function readStoredSidebarLeftOpen() {
+    throw uncapturedLayoutFailure();
+}
+/** Use the identically named method on a captured adapter for a bound write. */
+export function writeStoredSidebarLeftOpen(_open) {
+    throw uncapturedLayoutFailure();
+}

package/dist/layout/state.svelte.d.ts

@@ -0,0 +1,17 @@
+import { type LayoutHost, type LayoutReadResult, type LayoutWriteResult } from './runtime.ts';
+export interface LayoutStateInitOptions {
+    defaultSidebarLeftOpen?: boolean;
+}
+export interface LayoutState {
+    sidebarLeftOpen: boolean;
+    initialized: boolean;
+    readonly lastReadResult: LayoutReadResult | null;
+    readonly lastWriteResult: LayoutWriteResult | null;
+    init(options?: LayoutStateInitOptions): void;
+    setSidebarLeftOpen(open: boolean): void;
+    toggleSidebarLeft(): void;
+    dispose(): void;
+}
+export declare function createLayoutState(host: LayoutHost): LayoutState;
+/** Compatibility name only. A captured adapter supplies the usable root-bound state. */
+export declare const layoutState: LayoutState;