@shwfed/nuxt 0.10.13 → 0.10.15

package/dist/runtime/components/ui/drawer/DrawerDescription.d.vue.ts

@@ -0,0 +1,18 @@
+import type { DrawerDescriptionProps } from 'vaul-vue';
+import type { HTMLAttributes } from 'vue';
+type __VLS_Props = DrawerDescriptionProps & {
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/drawer/DrawerDescription.vue

@@ -0,0 +1,26 @@
+<script setup>
+import { reactiveOmit } from "@vueuse/core";
+import { useForwardProps } from "reka-ui";
+import { DrawerDescription } from "vaul-vue";
+import { cn } from "../../../utils/cn";
+defineOptions({
+  inheritAttrs: false
+});
+const props = defineProps({
+  asChild: { type: Boolean, required: false },
+  as: { type: null, required: false },
+  class: { type: null, required: false }
+});
+const delegatedProps = reactiveOmit(props, "class");
+const forwardedProps = useForwardProps(delegatedProps);
+</script>
+
+<template>
+  <DrawerDescription
+    data-slot="drawer-description"
+    v-bind="forwardedProps"
+    :class="cn('text-zinc-700 text-sm', props.class)"
+  >
+    <slot />
+  </DrawerDescription>
+</template>

package/dist/runtime/components/ui/drawer/DrawerDescription.vue.d.ts

@@ -0,0 +1,18 @@
+import type { DrawerDescriptionProps } from 'vaul-vue';
+import type { HTMLAttributes } from 'vue';
+type __VLS_Props = DrawerDescriptionProps & {
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/drawer/DrawerFooter.d.vue.ts

@@ -0,0 +1,17 @@
+import type { HTMLAttributes } from 'vue';
+type __VLS_Props = {
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/drawer/DrawerFooter.vue

@@ -0,0 +1,15 @@
+<script setup>
+import { cn } from "../../../utils/cn";
+const props = defineProps({
+  class: { type: null, required: false }
+});
+</script>
+
+<template>
+  <div
+    data-slot="drawer-footer"
+    :class="cn('mt-auto flex flex-col gap-2 p-4', props.class)"
+  >
+    <slot />
+  </div>
+</template>

package/dist/runtime/components/ui/drawer/DrawerFooter.vue.d.ts

@@ -0,0 +1,17 @@
+import type { HTMLAttributes } from 'vue';
+type __VLS_Props = {
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/drawer/DrawerHeader.d.vue.ts

@@ -0,0 +1,17 @@
+import type { HTMLAttributes } from 'vue';
+type __VLS_Props = {
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/drawer/DrawerHeader.vue

@@ -0,0 +1,15 @@
+<script setup>
+import { cn } from "../../../utils/cn";
+const props = defineProps({
+  class: { type: null, required: false }
+});
+</script>
+
+<template>
+  <div
+    data-slot="drawer-header"
+    :class="cn('flex flex-col gap-2 p-4 text-center sm:text-left', props.class)"
+  >
+    <slot />
+  </div>
+</template>

package/dist/runtime/components/ui/drawer/DrawerHeader.vue.d.ts

@@ -0,0 +1,17 @@
+import type { HTMLAttributes } from 'vue';
+type __VLS_Props = {
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/drawer/DrawerOverlay.d.vue.ts

@@ -0,0 +1,7 @@
+import type { HTMLAttributes } from 'vue';
+type __VLS_Props = {
+    class?: HTMLAttributes['class'];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/ui/drawer/DrawerOverlay.vue

@@ -0,0 +1,19 @@
+<script setup>
+import { DrawerOverlay } from "vaul-vue";
+import { cn } from "../../../utils/cn";
+const props = defineProps({
+  class: { type: null, required: false }
+});
+</script>
+
+<template>
+  <DrawerOverlay
+    data-slot="drawer-overlay"
+    :class="
+  cn(
+    'data-[state=closed]:animate-out data-[state=open]:animate-in data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-50 bg-black/50',
+    props.class
+  )
+"
+  />
+</template>

package/dist/runtime/components/ui/drawer/DrawerOverlay.vue.d.ts

@@ -0,0 +1,7 @@
+import type { HTMLAttributes } from 'vue';
+type __VLS_Props = {
+    class?: HTMLAttributes['class'];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/ui/drawer/DrawerTitle.d.vue.ts

@@ -0,0 +1,18 @@
+import type { DrawerTitleProps } from 'vaul-vue';
+import type { HTMLAttributes } from 'vue';
+type __VLS_Props = DrawerTitleProps & {
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/drawer/DrawerTitle.vue

@@ -0,0 +1,26 @@
+<script setup>
+import { reactiveOmit } from "@vueuse/core";
+import { useForwardProps } from "reka-ui";
+import { DrawerTitle } from "vaul-vue";
+import { cn } from "../../../utils/cn";
+defineOptions({
+  inheritAttrs: false
+});
+const props = defineProps({
+  asChild: { type: Boolean, required: false },
+  as: { type: null, required: false },
+  class: { type: null, required: false }
+});
+const delegatedProps = reactiveOmit(props, "class");
+const forwardedProps = useForwardProps(delegatedProps);
+</script>
+
+<template>
+  <DrawerTitle
+    data-slot="drawer-title"
+    v-bind="forwardedProps"
+    :class="cn('text-lg leading-none font-semibold', props.class)"
+  >
+    <slot />
+  </DrawerTitle>
+</template>

package/dist/runtime/components/ui/drawer/DrawerTitle.vue.d.ts

@@ -0,0 +1,18 @@
+import type { DrawerTitleProps } from 'vaul-vue';
+import type { HTMLAttributes } from 'vue';
+type __VLS_Props = DrawerTitleProps & {
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/drawer/DrawerTrigger.d.vue.ts

@@ -0,0 +1,14 @@
+import type { DrawerTriggerProps } from 'vaul-vue';
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<DrawerTriggerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DrawerTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/drawer/DrawerTrigger.vue

@@ -0,0 +1,19 @@
+<script setup>
+import { DrawerTrigger } from "vaul-vue";
+defineOptions({
+  inheritAttrs: false
+});
+const props = defineProps({
+  asChild: { type: Boolean, required: false },
+  as: { type: null, required: false }
+});
+</script>
+
+<template>
+  <DrawerTrigger
+    data-slot="drawer-trigger"
+    v-bind="props"
+  >
+    <slot />
+  </DrawerTrigger>
+</template>

package/dist/runtime/components/ui/drawer/DrawerTrigger.vue.d.ts

@@ -0,0 +1,14 @@
+import type { DrawerTriggerProps } from 'vaul-vue';
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<DrawerTriggerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DrawerTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/drawer/index.d.ts

@@ -0,0 +1,8 @@
+export { default as Drawer } from './Drawer.vue.js';
+export { default as DrawerClose } from './DrawerClose.vue.js';
+export { default as DrawerContent } from './DrawerContent.vue.js';
+export { default as DrawerDescription } from './DrawerDescription.vue.js';
+export { default as DrawerFooter } from './DrawerFooter.vue.js';
+export { default as DrawerHeader } from './DrawerHeader.vue.js';
+export { default as DrawerTitle } from './DrawerTitle.vue.js';
+export { default as DrawerTrigger } from './DrawerTrigger.vue.js';

package/dist/runtime/components/ui/drawer/index.js

@@ -0,0 +1,8 @@
+export { default as Drawer } from "./Drawer.vue";
+export { default as DrawerClose } from "./DrawerClose.vue";
+export { default as DrawerContent } from "./DrawerContent.vue";
+export { default as DrawerDescription } from "./DrawerDescription.vue";
+export { default as DrawerFooter } from "./DrawerFooter.vue";
+export { default as DrawerHeader } from "./DrawerHeader.vue";
+export { default as DrawerTitle } from "./DrawerTitle.vue";
+export { default as DrawerTrigger } from "./DrawerTrigger.vue";

package/dist/runtime/composables/useOverlay.d.ts

@@ -0,0 +1,86 @@
+import { Context, Deferred, Effect, type Scope } from 'effect';
+import { type VNode } from 'vue';
+export type OverlayAbortReason = 'close-all' | 'definition' | 'dismiss' | 'owner' | 'scope';
+export type OverlayAborted = Readonly<{
+    _tag: 'OverlayAborted';
+    reason: OverlayAbortReason;
+}>;
+export type OverlayResult = OverlayAborted | unknown;
+export type OverlayShellProps = Readonly<{
+    title?: string;
+    description?: string;
+    showCloseButton?: boolean;
+    breakpoint?: string;
+    dismissible?: boolean;
+}>;
+export type OverlayBodyProps = Readonly<Record<string, unknown>>;
+export type OverlaySessionInput = Readonly<{
+    shell?: Partial<OverlayShellProps>;
+    props?: Record<string, unknown>;
+}>;
+export type OverlaySessionPatch = Readonly<{
+    shell?: Partial<OverlayShellProps>;
+    props?: Record<string, unknown>;
+}>;
+export type OverlaySlotProps = Readonly<{
+    props: OverlayBodyProps;
+    shell: OverlayShellProps;
+    sessionId: string;
+    close: (value?: unknown) => void;
+    patch: (nextProps: Record<string, unknown>) => void;
+    isDesktop: boolean;
+}>;
+export type OverlayBodyRender = (props: OverlaySlotProps) => Array<VNode>;
+export type OverlayDefinition = Readonly<{
+    definitionId: string;
+    ownerId: string;
+    render: OverlayBodyRender;
+    shell?: OverlayShellProps;
+}>;
+type OverlaySession = {
+    sessionId: string;
+    definitionId: string;
+    shell: OverlayShellProps;
+    props: Record<string, unknown>;
+    deferred: Deferred.Deferred<OverlayResult, never>;
+};
+export type OverlayHandle = Readonly<{
+    sessionId: string;
+    patch: (patch: OverlaySessionPatch) => Effect.Effect<void>;
+    close: (value?: unknown) => Effect.Effect<void>;
+    result: Effect.Effect<OverlayResult>;
+}>;
+export type OverlayDefinitionNotFoundError = Readonly<{
+    _tag: 'OverlayDefinitionNotFoundError';
+    definitionId: string;
+}>;
+export interface OverlayRuntime {
+    definitions: Readonly<Record<string, OverlayDefinition>>;
+    sessions: ReadonlyArray<OverlaySession>;
+    topSession: OverlaySession | undefined;
+    registerDefinition: (definition: OverlayDefinition) => void;
+    unregisterDefinition: (definitionId: string, ownerId?: string) => void;
+    syncDefinitions: (ownerId: string, definitions: Array<OverlayDefinition>) => void;
+    isOpen: (sessionId: string) => boolean;
+    patchSync: (sessionId: string, patch: OverlaySessionPatch) => void;
+    closeSync: (sessionId: string, value?: unknown) => void;
+    closeTopSync: () => void;
+    closeAllSync: () => void;
+    open: (definitionId: string, options?: OverlaySessionInput) => Effect.Effect<OverlayHandle, OverlayDefinitionNotFoundError, Scope.Scope>;
+    patch: (sessionId: string, patch: OverlaySessionPatch) => Effect.Effect<void>;
+    close: (sessionId: string, value?: unknown) => Effect.Effect<void>;
+    closeTop: () => Effect.Effect<void>;
+    closeAll: () => Effect.Effect<void>;
+}
+declare const OverlayService_base: Context.TagClass<OverlayService, "shwfed/OverlayService", OverlayRuntime>;
+export declare class OverlayService extends OverlayService_base {
+}
+export declare function isOverlayAborted(value: unknown): value is OverlayAborted;
+export declare function useOverlay(): OverlayRuntime;
+export declare function provideOverlay<A, E, R>(effect: Effect.Effect<A, E, R>, runtime?: OverlayRuntime): Effect.Effect<A, E, Exclude<R, OverlayService>>;
+export declare function openOverlay(definitionId: string, options?: OverlaySessionInput): Effect.Effect<OverlayHandle, OverlayDefinitionNotFoundError, OverlayService | Scope.Scope>;
+export declare function patchOverlay(sessionId: string, patch: OverlaySessionPatch): Effect.Effect<void, never, OverlayService>;
+export declare function closeOverlay(sessionId: string, value?: unknown): Effect.Effect<void, never, OverlayService>;
+export declare function closeTopOverlay(): Effect.Effect<void, never, OverlayService>;
+export declare function closeAllOverlays(): Effect.Effect<void, never, OverlayService>;
+export {};

package/dist/runtime/composables/useOverlay.js

@@ -0,0 +1,201 @@
+import { Context, Deferred, Effect } from "effect";
+import { reactive, ref } from "vue";
+export class OverlayService extends Context.Tag("shwfed/OverlayService")() {
+}
+function createAborted(reason) {
+  return {
+    _tag: "OverlayAborted",
+    reason
+  };
+}
+function createDefinitionNotFoundError(definitionId) {
+  return {
+    _tag: "OverlayDefinitionNotFoundError",
+    definitionId
+  };
+}
+export function isOverlayAborted(value) {
+  return typeof value === "object" && value !== null && Reflect.get(value, "_tag") === "OverlayAborted" && typeof Reflect.get(value, "reason") === "string";
+}
+function createOverlayRuntime() {
+  const definitions = reactive({});
+  const sessions = ref([]);
+  function findSessionIndex(sessionId) {
+    return sessions.value.findIndex((session) => session.sessionId === sessionId);
+  }
+  function getDefinition(definitionId) {
+    return Reflect.get(definitions, definitionId);
+  }
+  function getSession(sessionId) {
+    return sessions.value.find((session) => session.sessionId === sessionId);
+  }
+  function removeSession(sessionId) {
+    const index = findSessionIndex(sessionId);
+    if (index < 0) {
+      return void 0;
+    }
+    const [session] = sessions.value.splice(index, 1);
+    return session;
+  }
+  function closeInternal(sessionId, value) {
+    return Effect.gen(function* () {
+      const session = removeSession(sessionId);
+      if (!session) {
+        return;
+      }
+      yield* Deferred.succeed(session.deferred, value);
+    });
+  }
+  function closeDefinitionSessions(definitionId, reason) {
+    const targetSessions = sessions.value.filter((session) => session.definitionId === definitionId).map((session) => session.sessionId);
+    for (const sessionId of targetSessions) {
+      void Effect.runPromise(closeInternal(sessionId, createAborted(reason)));
+    }
+  }
+  function registerDefinition(definition) {
+    Reflect.set(definitions, definition.definitionId, definition);
+  }
+  function unregisterDefinition(definitionId, ownerId) {
+    const definition = getDefinition(definitionId);
+    if (!definition) {
+      return;
+    }
+    if (ownerId !== void 0 && definition.ownerId !== ownerId) {
+      return;
+    }
+    Reflect.deleteProperty(definitions, definitionId);
+    closeDefinitionSessions(definitionId, ownerId === void 0 ? "definition" : "owner");
+  }
+  function syncDefinitions(ownerId, nextDefinitions) {
+    const nextIds = nextDefinitions.map((definition) => definition.definitionId);
+    const currentIds = Object.values(definitions).filter((definition) => definition.ownerId === ownerId).map((definition) => definition.definitionId);
+    for (const definitionId of currentIds) {
+      if (!nextIds.includes(definitionId)) {
+        unregisterDefinition(definitionId, ownerId);
+      }
+    }
+    for (const definition of nextDefinitions) {
+      registerDefinition(definition);
+    }
+  }
+  function patchSync(sessionId, patch) {
+    const session = getSession(sessionId);
+    if (!session) {
+      return;
+    }
+    if (patch.shell) {
+      session.shell = {
+        ...session.shell,
+        ...patch.shell
+      };
+    }
+    if (patch.props) {
+      session.props = {
+        ...session.props,
+        ...patch.props
+      };
+    }
+  }
+  function closeSync(sessionId, value) {
+    void Effect.runPromise(closeInternal(sessionId, value));
+  }
+  function closeTopSync() {
+    const topSession = sessions.value.at(-1);
+    if (!topSession) {
+      return;
+    }
+    closeSync(topSession.sessionId, createAborted("dismiss"));
+  }
+  function closeAllSync() {
+    const sessionIds = sessions.value.map((session) => session.sessionId);
+    for (const sessionId of sessionIds) {
+      closeSync(sessionId, createAborted("close-all"));
+    }
+  }
+  function createHandle(session) {
+    return {
+      sessionId: session.sessionId,
+      patch: (patch) => Effect.sync(() => {
+        patchSync(session.sessionId, patch);
+      }),
+      close: (value) => closeInternal(session.sessionId, value),
+      result: Deferred.await(session.deferred)
+    };
+  }
+  const runtime = {
+    get definitions() {
+      return definitions;
+    },
+    get sessions() {
+      return sessions.value;
+    },
+    get topSession() {
+      return sessions.value.at(-1);
+    },
+    registerDefinition,
+    unregisterDefinition,
+    syncDefinitions,
+    isOpen: (sessionId) => findSessionIndex(sessionId) >= 0,
+    patchSync,
+    closeSync,
+    closeTopSync,
+    closeAllSync,
+    open: (definitionId, options) => Effect.acquireRelease(
+      Effect.gen(function* () {
+        const definition = getDefinition(definitionId);
+        if (!definition) {
+          return yield* Effect.fail(createDefinitionNotFoundError(definitionId));
+        }
+        const deferred = yield* Deferred.make();
+        const session = {
+          sessionId: crypto.randomUUID(),
+          definitionId,
+          shell: {
+            ...definition.shell,
+            ...options?.shell
+          },
+          props: {
+            ...options?.props
+          },
+          deferred
+        };
+        sessions.value.push(session);
+        return createHandle(session);
+      }),
+      (handle) => closeInternal(handle.sessionId, createAborted("scope"))
+    ),
+    patch: (sessionId, patch) => Effect.sync(() => {
+      patchSync(sessionId, patch);
+    }),
+    close: (sessionId, value) => closeInternal(sessionId, value),
+    closeTop: () => Effect.sync(() => {
+      closeTopSync();
+    }),
+    closeAll: () => Effect.sync(() => {
+      closeAllSync();
+    })
+  };
+  return runtime;
+}
+const overlayRuntime = createOverlayRuntime();
+export function useOverlay() {
+  return overlayRuntime;
+}
+export function provideOverlay(effect, runtime = overlayRuntime) {
+  return effect.pipe(Effect.provideService(OverlayService, runtime));
+}
+export function openOverlay(definitionId, options) {
+  return Effect.flatMap(OverlayService, (overlay) => overlay.open(definitionId, options));
+}
+export function patchOverlay(sessionId, patch) {
+  return Effect.flatMap(OverlayService, (overlay) => overlay.patch(sessionId, patch));
+}
+export function closeOverlay(sessionId, value) {
+  return Effect.flatMap(OverlayService, (overlay) => overlay.close(sessionId, value));
+}
+export function closeTopOverlay() {
+  return Effect.flatMap(OverlayService, (overlay) => overlay.closeTop());
+}
+export function closeAllOverlays() {
+  return Effect.flatMap(OverlayService, (overlay) => overlay.closeAll());
+}

package/dist/runtime/layouts/default.d.vue.ts

@@ -1,6 +1,7 @@
 import type { Scope } from 'effect';
+import type { OverlayService as OverlayRuntimeService } from '../composables/useOverlay.js';
 import type { Sidebar as SidebarType } from '../composables/useNavigationTabs.js';
-type CommandEffect = import('effect').Effect.Effect<void>;
+type CommandEffect = import('effect').Effect.Effect<void, never, Scope.Scope | OverlayRuntimeService>;
 type ProfileCommandInputItem = Readonly<{
     id: string | number;
     title: string;

package/dist/runtime/layouts/default.vue.d.ts

@@ -1,6 +1,7 @@
 import type { Scope } from 'effect';
+import type { OverlayService as OverlayRuntimeService } from '../composables/useOverlay.js';
 import type { Sidebar as SidebarType } from '../composables/useNavigationTabs.js';
-type CommandEffect = import('effect').Effect.Effect<void>;
+type CommandEffect = import('effect').Effect.Effect<void, never, Scope.Scope | OverlayRuntimeService>;
 type ProfileCommandInputItem = Readonly<{
     id: string | number;
     title: string;

package/dist/runtime/plugins/overlay/index.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("#app").Plugin<{
+    overlay: import("../../composables/useOverlay.js").OverlayRuntime;
+}> & import("#app").ObjectPlugin<{
+    overlay: import("../../composables/useOverlay.js").OverlayRuntime;
+}>;
+export default _default;