@chelone/vue 0.6.0 → 0.9.0

package/dist/controllers/reference-field-test-harness.d.ts

@@ -0,0 +1,375 @@
+import { type Ref } from "vue";
+import { z } from "zod";
+import { type RecordValue } from "../record/record-context.js";
+import { type UseReferenceManyFieldControllerOptions, type UseReferenceManyFieldControllerReturn } from "./use-reference-many-field-controller.js";
+import { type UseReferenceOneFieldControllerOptions, type UseReferenceOneFieldControllerReturn } from "./use-reference-one-field-controller.js";
+declare const commentSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    post_id: z.ZodNumber;
+    body: z.ZodString;
+}, z.core.$strip>;
+declare const profileSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    post_id: z.ZodNumber;
+    bio: z.ZodString;
+}, z.core.$strip>;
+declare const resources: {
+    readonly posts: {
+        readonly schema: z.ZodObject<{
+            id: z.ZodNumber;
+            title: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly comments: {
+        readonly schema: z.ZodObject<{
+            id: z.ZodNumber;
+            post_id: z.ZodNumber;
+            body: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly profiles: {
+        readonly schema: z.ZodObject<{
+            id: z.ZodNumber;
+            post_id: z.ZodNumber;
+            bio: z.ZodString;
+        }, z.core.$strip>;
+    };
+};
+export type Resources = typeof resources;
+export type Comment = z.infer<typeof commentSchema>;
+export type Profile = z.infer<typeof profileSchema>;
+/**
+ * Mount a composable under a real `<Admin>`, with an ambient record published
+ * by an ancestor (`provide` only reaches descendants) whose ref the test can
+ * set later.
+ */
+export declare function mountProbe<TResult>(useProbe: () => TResult, initialRecord?: RecordValue, failWith?: Error): {
+    wrapper: import("@vue/test-utils").VueWrapper<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never> & {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: import("vue").Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<{}> & Readonly<{}>, never> & {} & {} & import("vue").ComponentCustomProperties & {}, import("vue").ComponentPublicInstance<NonNullable<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>>, {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: import("vue").Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<{}> & Readonly<{}>, never> & {} & {} & import("vue").ComponentCustomProperties & {} & Omit<NonNullable<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>>, keyof import("vue").VNodeProps | keyof import("vue").AllowedComponentProps>>>;
+    capture: {
+        result?: TResult;
+    };
+    record: Ref<RecordValue, RecordValue>;
+    observerCount: () => number;
+    dataObserverCount: () => number;
+    referenceSpy: import("vitest").Mock<(<TName extends "posts" | "comments" | "profiles">(resource: TName, params: import("@chelone/core").GetManyReferenceParams) => Promise<import("@chelone/core").GetManyReferenceResult<import("@chelone/core").RecordOf<{
+        readonly posts: {
+            readonly schema: z.ZodObject<{
+                id: z.ZodNumber;
+                title: z.ZodString;
+            }, z.core.$strip>;
+        };
+        readonly comments: {
+            readonly schema: z.ZodObject<{
+                id: z.ZodNumber;
+                post_id: z.ZodNumber;
+                body: z.ZodString;
+            }, z.core.$strip>;
+        };
+        readonly profiles: {
+            readonly schema: z.ZodObject<{
+                id: z.ZodNumber;
+                post_id: z.ZodNumber;
+                bio: z.ZodString;
+            }, z.core.$strip>;
+        };
+    }, TName>>>)>;
+};
+export declare const mountMany: (options?: Omit<UseReferenceManyFieldControllerOptions<"comments">, "reference" | "target">, record?: RecordValue, failWith?: Error) => {
+    wrapper: import("@vue/test-utils").VueWrapper<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never> & {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: import("vue").Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<{}> & Readonly<{}>, never> & {} & {} & import("vue").ComponentCustomProperties & {}, import("vue").ComponentPublicInstance<NonNullable<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>>, {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: import("vue").Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<{}> & Readonly<{}>, never> & {} & {} & import("vue").ComponentCustomProperties & {} & Omit<NonNullable<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>>, keyof import("vue").VNodeProps | keyof import("vue").AllowedComponentProps>>>;
+    capture: {
+        result?: UseReferenceManyFieldControllerReturn<{
+            id: number;
+            post_id: number;
+            body: string;
+        }> | undefined;
+    };
+    record: Ref<RecordValue, RecordValue>;
+    observerCount: () => number;
+    dataObserverCount: () => number;
+    referenceSpy: import("vitest").Mock<(<TName extends "posts" | "comments" | "profiles">(resource: TName, params: import("@chelone/core").GetManyReferenceParams) => Promise<import("@chelone/core").GetManyReferenceResult<import("@chelone/core").RecordOf<{
+        readonly posts: {
+            readonly schema: z.ZodObject<{
+                id: z.ZodNumber;
+                title: z.ZodString;
+            }, z.core.$strip>;
+        };
+        readonly comments: {
+            readonly schema: z.ZodObject<{
+                id: z.ZodNumber;
+                post_id: z.ZodNumber;
+                body: z.ZodString;
+            }, z.core.$strip>;
+        };
+        readonly profiles: {
+            readonly schema: z.ZodObject<{
+                id: z.ZodNumber;
+                post_id: z.ZodNumber;
+                bio: z.ZodString;
+            }, z.core.$strip>;
+        };
+    }, TName>>>)>;
+};
+export declare const mountOne: (options?: Omit<UseReferenceOneFieldControllerOptions<"profiles">, "reference" | "target">, record?: RecordValue, failWith?: Error) => {
+    wrapper: import("@vue/test-utils").VueWrapper<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never> & {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: import("vue").Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<{}> & Readonly<{}>, never> & {} & {} & import("vue").ComponentCustomProperties & {}, import("vue").ComponentPublicInstance<NonNullable<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>>, {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: import("vue").Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<{}> & Readonly<{}>, never> & {} & {} & import("vue").ComponentCustomProperties & {} & Omit<NonNullable<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>>, keyof import("vue").VNodeProps | keyof import("vue").AllowedComponentProps>>>;
+    capture: {
+        result?: UseReferenceOneFieldControllerReturn<{
+            id: number;
+            post_id: number;
+            bio: string;
+        }> | undefined;
+    };
+    record: Ref<RecordValue, RecordValue>;
+    observerCount: () => number;
+    dataObserverCount: () => number;
+    referenceSpy: import("vitest").Mock<(<TName extends "posts" | "comments" | "profiles">(resource: TName, params: import("@chelone/core").GetManyReferenceParams) => Promise<import("@chelone/core").GetManyReferenceResult<import("@chelone/core").RecordOf<{
+        readonly posts: {
+            readonly schema: z.ZodObject<{
+                id: z.ZodNumber;
+                title: z.ZodString;
+            }, z.core.$strip>;
+        };
+        readonly comments: {
+            readonly schema: z.ZodObject<{
+                id: z.ZodNumber;
+                post_id: z.ZodNumber;
+                body: z.ZodString;
+            }, z.core.$strip>;
+        };
+        readonly profiles: {
+            readonly schema: z.ZodObject<{
+                id: z.ZodNumber;
+                post_id: z.ZodNumber;
+                bio: z.ZodString;
+            }, z.core.$strip>;
+        };
+    }, TName>>>)>;
+};
+export {};

package/dist/controllers/use-controller-for-id.d.ts

@@ -5,7 +5,7 @@
  * the 4R release: the old controller's observer detaches the moment the id
  * moves on, and the last scope disposal releases the final one.
  */
-import { type Identifier, type MicroStore } from "@chelone/core";
+import { type Identifier, type MicroStore, type ResourceRecord } from "@chelone/core";
 import { type Ref } from "vue";
 import type { RecordValue } from "../record/record-context.js";
 export type SourceId = Identifier | undefined;
@@ -18,7 +18,7 @@ export interface BoundController<TController, TState> {
  * {@link getAtPath} so `source="author.id"` resolves the way the field
  * composables read it. Anything but a string or number reads as no key.
  */
-export declare function foreignKeyOf(record: RecordValue, source: string): SourceId;
+export declare function foreignKeyOf(record: RecordValue<ResourceRecord>, source: string): SourceId;
 /**
  * Builds `create(id)` inside a scope of its own and keeps it bound to `id`:
  * when `id` changes the new controller is built and bound first, then the

package/dist/controllers/use-controller-for-id.js

@@ -1,40 +1,61 @@
-import { getAtPath } from "@chelone/core";
-import { shallowRef, watch, onScopeDispose, effectScope } from "vue";
 import { useMicroStore } from "../store/use-micro-store.js";
+import { effectScope, onScopeDispose, shallowRef, watch } from "vue";
+import { getAtPath } from "@chelone/core";
+// src/controllers/use-controller-for-id.ts
+/**
+* Shared by the reference-field composables: one controller per resolved
+* record id, rebuilt when the id changes. Each controller lives in its own
+* effect scope with its own `useMicroStore` subscription, so stopping that scope is
+* the 4R release: the old controller's observer detaches the moment the id
+* moves on, and the last scope disposal releases the final one.
+*/
+/**
+* The foreign key `source` holds on the record, read through core's
+* {@link getAtPath} so `source="author.id"` resolves the way the field
+* composables read it. Anything but a string or number reads as no key.
+*/
 function foreignKeyOf(record, source) {
-  const value = getAtPath(record, source);
-  return typeof value === "string" || typeof value === "number" ? value : void 0;
+	const value = getAtPath(record, source);
+	return typeof value === "string" || typeof value === "number" ? value : void 0;
 }
+/**
+* Builds `create(id)` inside a scope of its own and keeps it bound to `id`:
+* when `id` changes the new controller is built and bound first, then the
+* previous scope stops, so a `create` that throws leaves the old binding live
+* and leaks nothing. The returned ref swaps synchronously on a change, so no
+* frame reads the previous record's rows. Call it from `setup`: the last
+* binding stops with the caller's scope.
+*/
 function useControllerForId(id, create) {
-  const bind = (value) => {
-    const scope = effectScope(true);
-    try {
-      const bound2 = scope.run(() => {
-        const controller = create(value);
-        return { controller, state: useMicroStore(controller) };
-      });
-      return { scope, bound: bound2 };
-    } catch (error) {
-      scope.stop();
-      throw error;
-    }
-  };
-  let current = bind(id.value);
-  const bound = shallowRef(current.bound);
-  watch(
-    id,
-    (next) => {
-      const previous = current;
-      current = bind(next);
-      bound.value = current.bound;
-      previous.scope.stop();
-    },
-    { flush: "sync" }
-  );
-  onScopeDispose(() => current.scope.stop());
-  return bound;
+	const bind = (value) => {
+		const scope = effectScope(true);
+		try {
+			const bound = scope.run(() => {
+				const controller = create(value);
+				return {
+					controller,
+					state: useMicroStore(controller)
+				};
+			});
+			if (bound === void 0) throw new Error("useControllerForId: the new effect scope was inactive");
+			return {
+				scope,
+				bound
+			};
+		} catch (error) {
+			scope.stop();
+			throw error;
+		}
+	};
+	let current = bind(id.value);
+	const bound = shallowRef(current.bound);
+	watch(id, (next) => {
+		const previous = current;
+		current = bind(next);
+		bound.value = current.bound;
+		previous.scope.stop();
+	}, { flush: "sync" });
+	onScopeDispose(() => current.scope.stop());
+	return bound;
 }
-export {
-  foreignKeyOf,
-  useControllerForId
-};
+export { foreignKeyOf, useControllerForId };

package/dist/controllers/use-create-controller.js

@@ -1,25 +1,33 @@
-import { createCreateController } from "@chelone/core";
-import { reactive, computed } from "vue";
 import { useCheloneContext } from "../context.js";
 import { useRequiredResource } from "../resource-context.js";
 import { useMicroStore } from "../store/use-micro-store.js";
 import { toControllerContext } from "./controller-context.js";
+import { computed, reactive } from "vue";
+import { createCreateController } from "@chelone/core";
+// src/controllers/use-create-controller.ts
+/**
+* `useCreateController` — the Vue bridge for the vanilla core create controller,
+* the twin of `@chelone/react`'s `useCreateController` (`controller-hooks.ts`).
+* A create has NOTHING to fetch (`isPending` is false from birth); the only
+* acquired resource is the shared update/create `MutationObserver`, attached on
+* mount and released on scope disposal through `useMicroStore`'s 4R lifecycle.
+*
+* `save` is the controller's own create pipeline over `ctx.queryClient` (the
+* vue-query client `<Admin>` provides): validate → persist → notify, resolving
+* the server's field errors on `ValidationError`. As with edit, the FORM
+* reconciliation is layered on in the form composables (Task 6) — this stays the
+* thin controller bridge the React twin mirrors.
+*/
 function useCreateController(options = {}) {
-  const ctx = useCheloneContext();
-  const resource = useRequiredResource("useCreateController", options);
-  const controller = createCreateController(
-    toControllerContext(ctx),
-    resource,
-    options
-  );
-  const state = useMicroStore(controller);
-  return reactive({
-    record: computed(() => state.value.record),
-    isPending: computed(() => state.value.isPending),
-    saving: computed(() => state.value.saving),
-    save: controller.save
-  });
+	const ctx = useCheloneContext();
+	const resource = useRequiredResource("useCreateController", options);
+	const controller = createCreateController(toControllerContext(ctx), resource, options);
+	const state = useMicroStore(controller);
+	return reactive({
+		record: computed(() => state.value.record),
+		isPending: computed(() => state.value.isPending),
+		saving: computed(() => state.value.saving),
+		save: controller.save
+	});
 }
-export {
-  useCreateController
-};
+export { useCreateController };

package/dist/controllers/use-delete-controller.js

@@ -1,23 +1,29 @@
-import { createDeleteController } from "@chelone/core";
-import { reactive, computed } from "vue";
 import { useCheloneContext } from "../context.js";
 import { useRequiredResource } from "../resource-context.js";
 import { useMicroStore } from "../store/use-micro-store.js";
 import { toControllerContext } from "./controller-context.js";
+import { computed, reactive } from "vue";
+import { createDeleteController } from "@chelone/core";
+// src/controllers/use-delete-controller.ts
+/**
+* `useDeleteController` — the Vue bridge for the vanilla core delete controller,
+* the twin of `@chelone/react`'s `useDeleteController` (`controller-hooks.ts`).
+* A delete has NOTHING to fetch; the only acquired resource is the shared
+* `MutationObserver`, attached on mount and released on scope disposal through
+* `useMicroStore`'s 4R lifecycle.
+*
+* `deleteOne` is the controller's own pipeline: delete → notify `deleted` →
+* request the list redirect → strip the id from the `${resource}.selectedIds`
+* selection. A provider error notifies `http_error` and resolves; it never rejects.
+*/
 function useDeleteController(options = {}) {
-  const ctx = useCheloneContext();
-  const resource = useRequiredResource("useDeleteController", options);
-  const controller = createDeleteController(
-    toControllerContext(ctx),
-    resource,
-    options
-  );
-  const state = useMicroStore(controller);
-  return reactive({
-    saving: computed(() => state.value.saving),
-    deleteOne: controller.deleteOne
-  });
+	const ctx = useCheloneContext();
+	const resource = useRequiredResource("useDeleteController", options);
+	const controller = createDeleteController(toControllerContext(ctx), resource, options);
+	const state = useMicroStore(controller);
+	return reactive({
+		saving: computed(() => state.value.saving),
+		deleteOne: controller.deleteOne
+	});
 }
-export {
-  useDeleteController
-};
+export { useDeleteController };