@chelone/vue 0.5.0 → 0.7.0

package/dist/realtime/locks.js

@@ -1,163 +1,148 @@
-import { createMicroStore, assertRealtimeDataProvider, createLockSession, resolveLockIdentity, getLockOptions, subscribeLiveLock, getLocksOptions, subscribeLiveLocks } from "@chelone/core";
-import { useQuery, useMutation } from "@tanstack/vue-query";
-import { inject, computed, toValue, watchEffect } from "vue";
 import { useCheloneContext } from "../context.js";
 import { RecordContextKey } from "../record/record-context.js";
 import { useResourceContext } from "../resource-context.js";
 import { useMicroStore } from "../store/use-micro-store.js";
-const isEnabled = (enabled) => enabled === void 0 || toValue(enabled);
+import { computed, inject, toValue, watchEffect } from "vue";
+import { assertRealtimeDataProvider, createLockSession, createMicroStore, getLockOptions, getLocksOptions, resolveLockIdentity, subscribeLiveLock, subscribeLiveLocks } from "@chelone/core";
+import { useMutation, useQuery } from "@tanstack/vue-query";
+// src/realtime/locks.ts
+var isEnabled = (enabled) => enabled === void 0 || toValue(enabled);
+/** Takes a record's lock. Rejects, and stores the error, when another identity holds it. */
 function useLock() {
-  const { dataProvider, authProvider } = useCheloneContext();
-  const mutation = useMutation({
-    mutationFn: async ({
-      resource,
-      id,
-      identity,
-      meta
-    }) => {
-      assertRealtimeDataProvider(dataProvider, "useLock");
-      return dataProvider.lock(resource, {
-        id,
-        identity: await resolveLockIdentity(authProvider, identity),
-        ...meta ? { meta } : {}
-      });
-    }
-  });
-  return {
-    lock: (resource, params) => mutation.mutateAsync({ resource, ...params }),
-    isLoading: computed(() => mutation.isPending.value),
-    error: computed(() => mutation.error.value)
-  };
+	const { dataProvider, authProvider } = useCheloneContext();
+	const mutation = useMutation({ mutationFn: async ({ resource, id, identity, meta }) => {
+		assertRealtimeDataProvider(dataProvider, "useLock");
+		return dataProvider.lock(resource, {
+			id,
+			identity: await resolveLockIdentity(authProvider, identity),
+			...meta ? { meta } : {}
+		});
+	} });
+	return {
+		lock: (resource, params) => mutation.mutateAsync({
+			resource,
+			...params
+		}),
+		isLoading: computed(() => mutation.isPending.value),
+		error: computed(() => mutation.error.value)
+	};
 }
+/** Releases a record's lock. Rejects, and stores the error, when another identity holds it. */
 function useUnlock() {
-  const { dataProvider, authProvider } = useCheloneContext();
-  const mutation = useMutation({
-    mutationFn: async ({
-      resource,
-      id,
-      identity,
-      meta
-    }) => {
-      assertRealtimeDataProvider(dataProvider, "useUnlock");
-      return dataProvider.unlock(resource, {
-        id,
-        identity: await resolveLockIdentity(authProvider, identity),
-        ...meta ? { meta } : {}
-      });
-    }
-  });
-  return {
-    unlock: (resource, params) => mutation.mutateAsync({ resource, ...params }),
-    isLoading: computed(() => mutation.isPending.value),
-    error: computed(() => mutation.error.value)
-  };
+	const { dataProvider, authProvider } = useCheloneContext();
+	const mutation = useMutation({ mutationFn: async ({ resource, id, identity, meta }) => {
+		assertRealtimeDataProvider(dataProvider, "useUnlock");
+		return dataProvider.unlock(resource, {
+			id,
+			identity: await resolveLockIdentity(authProvider, identity),
+			...meta ? { meta } : {}
+		});
+	} });
+	return {
+		unlock: (resource, params) => mutation.mutateAsync({
+			resource,
+			...params
+		}),
+		isLoading: computed(() => mutation.isPending.value),
+		error: computed(() => mutation.error.value)
+	};
 }
+/** One record's lock, or `null` when it is free. */
 function useGetLock(resource, params, options = {}) {
-  const ctx = useCheloneContext();
-  return useQuery(
-    computed(() => ({
-      ...getLockOptions(ctx, resource, toValue(params)),
-      enabled: isEnabled(options.enabled)
-    }))
-  );
+	const ctx = useCheloneContext();
+	return useQuery(computed(() => ({
+		...getLockOptions(ctx, resource, toValue(params)),
+		enabled: isEnabled(options.enabled)
+	})));
 }
+/** Every lock held on a resource. */
 function useGetLocks(resource, options = {}) {
-  const ctx = useCheloneContext();
-  return useQuery(
-    computed(() => ({
-      ...getLocksOptions(ctx, resource),
-      enabled: isEnabled(options.enabled)
-    }))
-  );
+	const ctx = useCheloneContext();
+	return useQuery(computed(() => ({
+		...getLocksOptions(ctx, resource),
+		enabled: isEnabled(options.enabled)
+	})));
 }
+/** `useGetLock`, kept fresh: refetches when the lock is taken or released, or the connection comes back. */
 function useGetLockLive(resource, params, options = {}) {
-  const ctx = useCheloneContext();
-  const query = useGetLock(resource, params, options);
-  watchEffect((onCleanup) => {
-    if (!isEnabled(options.enabled)) return;
-    onCleanup(subscribeLiveLock(ctx, resource, toValue(params).id).stop);
-  });
-  return query;
+	const ctx = useCheloneContext();
+	const query = useGetLock(resource, params, options);
+	watchEffect((onCleanup) => {
+		if (!isEnabled(options.enabled)) return;
+		onCleanup(subscribeLiveLock(ctx, resource, toValue(params).id).stop);
+	});
+	return query;
 }
+/** `useGetLocks`, kept fresh: refetches when any lock of the resource changes, or the connection comes back. */
 function useGetLocksLive(resource, options = {}) {
-  const ctx = useCheloneContext();
-  const query = useGetLocks(resource, options);
-  watchEffect((onCleanup) => {
-    if (!isEnabled(options.enabled)) return;
-    onCleanup(subscribeLiveLocks(ctx, resource).stop);
-  });
-  return query;
+	const ctx = useCheloneContext();
+	const query = useGetLocks(resource, options);
+	watchEffect((onCleanup) => {
+		if (!isEnabled(options.enabled)) return;
+		onCleanup(subscribeLiveLocks(ctx, resource).stop);
+	});
+	return query;
 }
-const idleLockState = {
-  lock: null,
-  isLocking: false,
-  error: null
+var idleLockState = {
+	lock: null,
+	isLocking: false,
+	error: null
 };
-function useLockOnMount({
-  resource,
-  id,
-  identity,
-  meta,
-  onLockError
-} = {}) {
-  const { dataProvider, authProvider } = useCheloneContext();
-  const ambientResource = useResourceContext();
-  const ambientRecord = inject(RecordContextKey, null);
-  const resolvedResource = computed(() => toValue(resource) ?? ambientResource);
-  const resolvedId = computed(
-    () => toValue(id) ?? ambientRecord?.value?.id
-  );
-  const resolvedIdentity = computed(() => toValue(identity));
-  const mirror = createMicroStore(idleLockState);
-  const state = useMicroStore(mirror);
-  let previous = Promise.resolve();
-  watchEffect((onCleanup) => {
-    const resourceName = resolvedResource.value;
-    const recordId = resolvedId.value;
-    const holder = resolvedIdentity.value;
-    if (resourceName === void 0 || recordId == null) return;
-    if (holder === void 0 && !authProvider?.getIdentity) return;
-    assertRealtimeDataProvider(dataProvider, "useLockOnMount");
-    const session = createLockSession({
-      dataProvider,
-      resource: resourceName,
-      id: recordId,
-      getIdentity: () => resolveLockIdentity(authProvider, holder),
-      meta,
-      onError: onLockError
-    });
-    let cancelled = false;
-    let unsubscribe = () => {
-    };
-    mirror.setState({ ...idleLockState, isLocking: true });
-    const turn = previous;
-    void turn.then(() => {
-      if (cancelled) return;
-      unsubscribe = session.store.subscribe(
-        () => mirror.setState(session.store.getSnapshot())
-      );
-      void session.start();
-      mirror.setState(session.store.getSnapshot());
-    });
-    onCleanup(() => {
-      cancelled = true;
-      unsubscribe();
-      mirror.setState(idleLockState);
-      previous = turn.then(() => session.stop());
-    });
-  });
-  return {
-    lock: computed(() => state.value.lock),
-    isLocking: computed(() => state.value.isLocking),
-    lockError: computed(() => state.value.error)
-  };
+/**
+* Holds a record's lock for as long as the component lives. A changing
+* resource, id or identity releases the old lock and takes the new one. With
+* no resource, id or identity (explicit, or from the auth provider) it takes
+* nothing and reports no error.
+*/
+function useLockOnMount({ resource, id, identity, meta, onLockError } = {}) {
+	const { dataProvider, authProvider } = useCheloneContext();
+	const ambientResource = useResourceContext();
+	const ambientRecord = inject(RecordContextKey, null);
+	const resolvedResource = computed(() => toValue(resource) ?? ambientResource);
+	const resolvedId = computed(() => toValue(id) ?? ambientRecord?.value?.id);
+	const resolvedIdentity = computed(() => toValue(identity));
+	const mirror = createMicroStore(idleLockState);
+	const state = useMicroStore(mirror);
+	let previous = Promise.resolve();
+	watchEffect((onCleanup) => {
+		const resourceName = resolvedResource.value;
+		const recordId = resolvedId.value;
+		const holder = resolvedIdentity.value;
+		if (resourceName === void 0 || recordId == null) return;
+		if (holder === void 0 && !authProvider?.getIdentity) return;
+		assertRealtimeDataProvider(dataProvider, "useLockOnMount");
+		const session = createLockSession({
+			dataProvider,
+			resource: resourceName,
+			id: recordId,
+			getIdentity: () => resolveLockIdentity(authProvider, holder),
+			meta,
+			onError: onLockError
+		});
+		let cancelled = false;
+		let unsubscribe = () => {};
+		mirror.setState({
+			...idleLockState,
+			isLocking: true
+		});
+		const turn = previous;
+		turn.then(() => {
+			if (cancelled) return;
+			unsubscribe = session.store.subscribe(() => mirror.setState(session.store.getSnapshot()));
+			session.start();
+			mirror.setState(session.store.getSnapshot());
+		});
+		onCleanup(() => {
+			cancelled = true;
+			unsubscribe();
+			mirror.setState(idleLockState);
+			previous = turn.then(() => session.stop());
+		});
+	});
+	return {
+		lock: computed(() => state.value.lock),
+		isLocking: computed(() => state.value.isLocking),
+		lockError: computed(() => state.value.error)
+	};
 }
-export {
-  useGetLock,
-  useGetLockLive,
-  useGetLocks,
-  useGetLocksLive,
-  useLock,
-  useLockOnMount,
-  useUnlock
-};
+export { useGetLock, useGetLockLive, useGetLocks, useGetLocksLive, useLock, useLockOnMount, useUnlock };

package/dist/realtime/presence.js

@@ -1,65 +1,63 @@
-import { presenceTopic, toPresenceUser, createMicroStore, assertRealtimeDataProvider, createPresenceSession } from "@chelone/core";
-import { inject, computed, toValue, watchEffect } from "vue";
 import { useOptionalIdentity } from "../auth/auth-hooks.js";
 import { useCheloneContext } from "../context.js";
 import { RecordContextKey } from "../record/record-context.js";
 import { useResourceContext } from "../resource-context.js";
 import { useMicroStore } from "../store/use-micro-store.js";
-const idleState = { users: [] };
-function usePresence({
-  topic,
-  user,
-  heartbeatMs,
-  staleMs,
-  enabled
-} = {}) {
-  const { dataProvider } = useCheloneContext();
-  const ambientResource = useResourceContext();
-  const ambientRecord = inject(RecordContextKey, null);
-  const { identity } = useOptionalIdentity();
-  const resolvedTopic = computed(() => {
-    const explicit = toValue(topic);
-    if (explicit !== void 0) return explicit;
-    const id = ambientRecord?.value?.id;
-    return ambientResource !== void 0 && id != null ? presenceTopic(ambientResource, id) : void 0;
-  });
-  const resolvedUser = computed(
-    () => toValue(user) ?? (identity.value ? toPresenceUser(identity.value) : void 0)
-  );
-  const userId = computed(() => resolvedUser.value?.id);
-  const userName = computed(() => resolvedUser.value?.name);
-  const userAvatar = computed(() => resolvedUser.value?.avatar);
-  const mirror = createMicroStore(idleState);
-  const state = useMicroStore(mirror);
-  watchEffect((onCleanup) => {
-    const topicName = resolvedTopic.value;
-    const id = userId.value;
-    const name = userName.value;
-    if (enabled !== void 0 && !toValue(enabled)) return;
-    if (topicName === void 0 || id === void 0 || name === void 0)
-      return;
-    assertRealtimeDataProvider(dataProvider, "usePresence");
-    const avatar = userAvatar.value;
-    const session = createPresenceSession({
-      dataProvider,
-      topic: topicName,
-      user: { id, name, ...avatar !== void 0 ? { avatar } : {} },
-      heartbeatMs: toValue(heartbeatMs),
-      staleMs: toValue(staleMs)
-    });
-    const unsubscribe = session.store.subscribe(
-      () => mirror.setState(session.store.getSnapshot())
-    );
-    session.start();
-    mirror.setState(session.store.getSnapshot());
-    onCleanup(() => {
-      unsubscribe();
-      session.stop();
-      mirror.setState(idleState);
-    });
-  });
-  return { users: computed(() => state.value.users) };
+import { computed, inject, toValue, watchEffect } from "vue";
+import { assertRealtimeDataProvider, createMicroStore, createPresenceSession, presenceTopic, toPresenceUser } from "@chelone/core";
+// src/realtime/presence.ts
+var idleState = { users: [] };
+/**
+* Announces the current user on a topic for as long as the component lives
+* and returns the other users there. A changing topic or user leaves the old
+* topic and joins the new one. With no topic, no user or `enabled` false it
+* announces nothing and `users` stays empty.
+*/
+function usePresence({ topic, user, heartbeatMs, staleMs, enabled } = {}) {
+	const { dataProvider } = useCheloneContext();
+	const ambientResource = useResourceContext();
+	const ambientRecord = inject(RecordContextKey, null);
+	const { identity } = useOptionalIdentity();
+	const resolvedTopic = computed(() => {
+		const explicit = toValue(topic);
+		if (explicit !== void 0) return explicit;
+		const id = ambientRecord?.value?.id;
+		return ambientResource !== void 0 && id != null ? presenceTopic(ambientResource, id) : void 0;
+	});
+	const resolvedUser = computed(() => toValue(user) ?? (identity.value ? toPresenceUser(identity.value) : void 0));
+	const userId = computed(() => resolvedUser.value?.id);
+	const userName = computed(() => resolvedUser.value?.name);
+	const userAvatar = computed(() => resolvedUser.value?.avatar);
+	const mirror = createMicroStore(idleState);
+	const state = useMicroStore(mirror);
+	watchEffect((onCleanup) => {
+		const topicName = resolvedTopic.value;
+		const id = userId.value;
+		const name = userName.value;
+		if (enabled !== void 0 && !toValue(enabled)) return;
+		if (topicName === void 0 || id === void 0 || name === void 0) return;
+		assertRealtimeDataProvider(dataProvider, "usePresence");
+		const avatar = userAvatar.value;
+		const session = createPresenceSession({
+			dataProvider,
+			topic: topicName,
+			user: {
+				id,
+				name,
+				...avatar !== void 0 ? { avatar } : {}
+			},
+			heartbeatMs: toValue(heartbeatMs),
+			staleMs: toValue(staleMs)
+		});
+		const unsubscribe = session.store.subscribe(() => mirror.setState(session.store.getSnapshot()));
+		session.start();
+		mirror.setState(session.store.getSnapshot());
+		onCleanup(() => {
+			unsubscribe();
+			session.stop();
+			mirror.setState(idleState);
+		});
+	});
+	return { users: computed(() => state.value.users) };
 }
-export {
-  usePresence
-};
+export { usePresence };

package/dist/realtime/subscribe.js

@@ -1,58 +1,57 @@
-import { assertRealtimeDataProvider, createRealtimeStatusStore, recordTopic, resourceTopic } from "@chelone/core";
-import { onScopeDispose, computed, watchEffect, toValue } from "vue";
 import { useCheloneContext } from "../context.js";
 import { useMicroStore } from "../store/use-micro-store.js";
+import { computed, onScopeDispose, toValue, watchEffect } from "vue";
+import { assertRealtimeDataProvider, createRealtimeStatusStore, recordTopic, resourceTopic } from "@chelone/core";
+// src/realtime/subscribe.ts
+/**
+* Listens to `topic` for as long as the component lives and `enabled` is
+* true. A changing topic or `enabled` resubscribes. The callback is read at
+* subscribe time; a Vue callback closes over live refs, so it needs no
+* latest-callback ref.
+*/
 function useSubscribe(topic, callback, { enabled } = {}) {
-  const { dataProvider } = useCheloneContext();
-  watchEffect((onCleanup) => {
-    if (enabled !== void 0 && !toValue(enabled)) return;
-    assertRealtimeDataProvider(dataProvider, "useSubscribe");
-    onCleanup(dataProvider.subscribe(toValue(topic), callback));
-  });
+	const { dataProvider } = useCheloneContext();
+	watchEffect((onCleanup) => {
+		if (enabled !== void 0 && !toValue(enabled)) return;
+		assertRealtimeDataProvider(dataProvider, "useSubscribe");
+		onCleanup(dataProvider.subscribe(toValue(topic), callback));
+	});
 }
+/** Returns `subscribe(topic, callback)` for subscriptions made on demand; the caller owns the unsubscribe. */
 function useSubscribeCallback() {
-  const { dataProvider } = useCheloneContext();
-  assertRealtimeDataProvider(dataProvider, "useSubscribeCallback");
-  return (topic, callback) => dataProvider.subscribe(topic, callback);
+	const { dataProvider } = useCheloneContext();
+	assertRealtimeDataProvider(dataProvider, "useSubscribeCallback");
+	return (topic, callback) => dataProvider.subscribe(topic, callback);
 }
+/** Listens to one record's topic. Does nothing while `id` is null or undefined; `0` is an id. */
 function useSubscribeToRecord(resource, id, callback, { enabled } = {}) {
-  useSubscribe(
-    () => recordTopic(toValue(resource), toValue(id) ?? ""),
-    callback,
-    {
-      enabled: () => toValue(id) != null && (enabled === void 0 || toValue(enabled))
-    }
-  );
+	useSubscribe(() => recordTopic(toValue(resource), toValue(id) ?? ""), callback, { enabled: () => toValue(id) != null && (enabled === void 0 || toValue(enabled)) });
 }
+/** Listens to a resource's topic: creates, and the ids of any write. */
 function useSubscribeToRecordList(resource, callback, options = {}) {
-  useSubscribe(() => resourceTopic(toValue(resource)), callback, options);
+	useSubscribe(() => resourceTopic(toValue(resource)), callback, options);
 }
+/** Returns `publish(topic, event)` over the data provider. */
 function usePublish() {
-  const { dataProvider } = useCheloneContext();
-  assertRealtimeDataProvider(dataProvider, "usePublish");
-  return dataProvider.publish.bind(dataProvider);
+	const { dataProvider } = useCheloneContext();
+	assertRealtimeDataProvider(dataProvider, "usePublish");
+	return dataProvider.publish.bind(dataProvider);
 }
+/** Calls `callback` each time the transport reconnects. Does nothing when the transport cannot tell. */
 function useOnReconnect(callback) {
-  const { dataProvider } = useCheloneContext();
-  assertRealtimeDataProvider(dataProvider, "useOnReconnect");
-  const unsubscribe = dataProvider.onReconnect?.(callback);
-  if (unsubscribe) onScopeDispose(unsubscribe);
+	const { dataProvider } = useCheloneContext();
+	assertRealtimeDataProvider(dataProvider, "useOnReconnect");
+	const unsubscribe = dataProvider.onReconnect?.(callback);
+	if (unsubscribe) onScopeDispose(unsubscribe);
 }
+/** The connection status and the latest transport error, as refs that follow the transport. */
 function useRealtimeStatus() {
-  const { dataProvider } = useCheloneContext();
-  assertRealtimeDataProvider(dataProvider, "useRealtimeStatus");
-  const state = useMicroStore(createRealtimeStatusStore(dataProvider));
-  return {
-    status: computed(() => state.value.status),
-    lastError: computed(() => state.value.lastError)
-  };
+	const { dataProvider } = useCheloneContext();
+	assertRealtimeDataProvider(dataProvider, "useRealtimeStatus");
+	const state = useMicroStore(createRealtimeStatusStore(dataProvider));
+	return {
+		status: computed(() => state.value.status),
+		lastError: computed(() => state.value.lastError)
+	};
 }
-export {
-  useOnReconnect,
-  usePublish,
-  useRealtimeStatus,
-  useSubscribe,
-  useSubscribeCallback,
-  useSubscribeToRecord,
-  useSubscribeToRecordList
-};
+export { useOnReconnect, usePublish, useRealtimeStatus, useSubscribe, useSubscribeCallback, useSubscribeToRecord, useSubscribeToRecordList };

package/dist/record/record-context.d.ts

@@ -17,7 +17,7 @@
  * the current value (a plain read) so field code never juggles refs.
  */
 import type { LooseRecord } from "@chelone/core";
-import { type InjectionKey, type Ref } from "vue";
+import { type ComputedRef, type InjectionKey, type Ref } from "vue";
 /** A record in scope, or `undefined` when none is (mirrors ra-core's union). */
 export type RecordValue<RecordType = LooseRecord> = RecordType | undefined;
 /** The provide/inject key for the ambient record (a reactive ref). */
@@ -34,9 +34,17 @@ export interface UseRecordContextOptions<RecordType = LooseRecord> {
     /** Target a specific record; wins over the ambient one. */
     record?: RecordValue<RecordType>;
 }
+/**
+ * The reactive form of {@link useRecordContext}: a computed that follows both
+ * the ambient ref and the `record` getter, for a component whose `record` prop
+ * or ambient record can change after setup (an Edit view publishes its record
+ * once the fetch lands). Call it in `setup`, since it injects.
+ */
+export declare function useRecordContextRef<RecordType = LooseRecord>(record?: () => RecordValue<RecordType>): ComputedRef<RecordValue<RecordType>>;
 /**
  * Read the ambient record's current value. A `record` prop always wins over the
  * injected ref (parity: ra-core's `useRecordContext`). Returns `undefined` when
- * neither a prop nor an ancestor provider supplies one.
+ * neither a prop nor an ancestor provider supplies one. A plain read at call
+ * time: use {@link useRecordContextRef} where the record can change.
  */
 export declare function useRecordContext<RecordType = LooseRecord>(options?: UseRecordContextOptions<RecordType>): RecordValue<RecordType>;

package/dist/record/record-context.js

@@ -1,18 +1,38 @@
-import { isRef, ref, provide, inject } from "vue";
-const RecordContextKey = /* @__PURE__ */ Symbol(
-  "chelone-record-context"
-);
+import { computed, inject, isRef, provide, ref } from "vue";
+// src/record/record-context.ts
+/** The provide/inject key for the ambient record (a reactive ref). */
+var RecordContextKey = Symbol("chelone-record-context");
+/**
+* Provide the ambient record to the subtree. Accepts a bare record or a `Ref`
+* (a controller's reactive record); a bare value is wrapped so the contract is
+* uniform. Mirrors ra-core: an absent record still provides (an `undefined`
+* ref) — a nested field reads `undefined` and renders its empty state.
+*/
 function provideRecordContext(record) {
-  const asRef = isRef(record) ? record : ref(record);
-  provide(RecordContextKey, asRef);
+	const asRef = isRef(record) ? record : ref(record);
+	provide(RecordContextKey, asRef);
 }
+/**
+* The reactive form of {@link useRecordContext}: a computed that follows both
+* the ambient ref and the `record` getter, for a component whose `record` prop
+* or ambient record can change after setup (an Edit view publishes its record
+* once the fetch lands). Call it in `setup`, since it injects.
+*/
+function useRecordContextRef(record) {
+	const injected = inject(RecordContextKey, null);
+	return computed(() => {
+		const explicit = record?.();
+		if (explicit !== void 0) return explicit;
+		return injected?.value;
+	});
+}
+/**
+* Read the ambient record's current value. A `record` prop always wins over the
+* injected ref (parity: ra-core's `useRecordContext`). Returns `undefined` when
+* neither a prop nor an ancestor provider supplies one. A plain read at call
+* time: use {@link useRecordContextRef} where the record can change.
+*/
 function useRecordContext(options) {
-  if (options?.record !== void 0) return options.record;
-  const injected = inject(RecordContextKey, null);
-  return injected?.value;
+	return useRecordContextRef(() => options?.record).value;
 }
-export {
-  RecordContextKey,
-  provideRecordContext,
-  useRecordContext
-};
+export { RecordContextKey, provideRecordContext, useRecordContext, useRecordContextRef };

package/dist/record/use-field-value.d.ts

@@ -21,10 +21,10 @@ export interface UseFieldValueOptions<RecordType = LooseRecord, TPath extends So
     /** Override the ambient record (a static record wins over the context ref). */
     record?: RecordValue<RecordType>;
     /**
-     * Returned only when the resolved value is `undefined`. Untyped on purpose:
-     * the result type is the record's value at `source`, not the default's.
+     * Returned only when the resolved value is `undefined`; it has the type of
+     * the value at `source`.
      */
-    defaultValue?: unknown;
+    defaultValue?: NoInfer<SourceValue<RecordType, TPath>>;
 }
 /**
  * The value at `source` off the ambient (or overridden) record, reactively. A