@signal-tree/vue 15.0.0-rc.14

package/LICENSE

@@ -0,0 +1,202 @@
+                               Apache License
+                         Version 2.0, January 2004
+                      http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+        Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+        stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+        that You distribute, all copyright, patent, trademark, and
+        attribution notices from the Source form of the Work,
+        excluding those notices that do not pertain to any part of
+        the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+        distribution, then any Derivative Works that You distribute must
+        include a readable copy of the attribution notices contained
+        within such NOTICE file, excluding those notices that do not
+        pertain to any part of the Derivative Works, in at least one
+        of the following places: within a NOTICE text file distributed
+        as part of the Derivative Works; within the Source form or
+        documentation, if provided along with the Derivative Works; or,
+        within a display generated by the Derivative Works, if and
+        wherever such third-party notices normally appear. The contents
+        of the NOTICE file are for informational purposes only and
+        do not modify the License. You may add Your own attribution
+        notices within Derivative Works that You distribute, alongside
+        or as an addendum to the NOTICE text from the Work, provided
+        that such additional attribution notices cannot be construed
+        as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+    To apply the Apache License to your work, attach the following
+    boilerplate notice, with the fields enclosed by brackets "[]"
+    replaced with your own identifying information. (Don't include
+    the brackets!)  The text should be enclosed in the appropriate
+    comment syntax for the file format. We also recommend that a
+    file or class name and description of purpose be included on the
+    same "printed page" as the copyright notice for easier
+    identification within third-party archives.
+
+   Copyright 2024-2026 Jonathan D Borgia and SignalTree contributors
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ 

package/NOTICE

@@ -0,0 +1,13 @@
+SignalTree
+Copyright 2024-2026 Jonathan D Borgia and SignalTree contributors
+
+This product includes software developed by Jonathan D Borgia
+and the SignalTree contributors (https://github.com/JBorgia/signaltree).
+
+Licensed under the Apache License, Version 2.0. See the LICENSE file
+for the full terms.
+
+"SignalTree" and the SignalTree name and logo are marks of the
+copyright holder. The Apache License does not grant permission to use
+them (LICENSE section 6); forks and derivative works must be
+distributed under a different name.

package/README.md

@@ -0,0 +1,37 @@
+# `@signal-tree/vue`
+
+Vue-native SignalTree realization. State remains owned by the framework-neutral
+kernel; terminal leaves are Vue refs and derived values are computed refs.
+
+## Install
+
+```bash
+npm install @signal-tree/vue
+```
+
+Vue 3.5 or newer is required as a peer dependency.
+
+The canonical v15 model and composition guidance ships with this package as
+[llms.txt](llms.txt).
+
+## Use
+
+```ts
+import { signalTree } from '@signal-tree/vue';
+
+const tree = signalTree(
+  { profile: { name: 'Ada' } },
+  {
+    derived: ($) => ({
+      greeting: () => `Hello, ${$.profile.name.value}`,
+    }),
+  }
+);
+
+tree.$.profile.name.value = 'Grace';
+console.log(tree.$.greeting.value); // Hello, Grace
+```
+
+The ref can be passed directly to `watch()`, `computed()`, or `v-model`.
+Object branches and the root `$` remain callable whole-value accessors. Vue owns
+dependency tracking; the kernel remains the only state and write authority.

package/dist/index.js

@@ -0,0 +1 @@
+import{asReadonly as asReadonly$1}from"@signal-tree/kernel";export*from"@signal-tree/kernel";import{createSignalTreeFactory}from"@signal-tree/kernel/adapter";import{createVueObservationAdapter}from"./lib/vue-observation.js";const signalTree=(initialState,config)=>createSignalTreeFactory(createVueObservationAdapter())(initialState,config);const asReadonly=asReadonly$1;export{asReadonly,signalTree};

package/dist/lib/vue-observation.js

@@ -0,0 +1,117 @@
+import { computed, shallowRef, triggerRef } from 'vue';
+
+const wrapReadonlyCell = source => {
+  const cell = () => source.value;
+  Object.defineProperties(cell, {
+    __v_isRef: {
+      value: true
+    },
+    __v_isReadonly: {
+      value: true
+    },
+    effect: {
+      value: source.effect
+    },
+    value: {
+      get: () => source.value
+    }
+  });
+  return cell;
+};
+const createReadonlyCell = read => wrapReadonlyCell(computed(read));
+const createWritableCell = read => {
+  const cell = () => read();
+  Object.defineProperties(cell, {
+    __v_isRef: {
+      value: true
+    },
+    value: {
+      get: read,
+      set: value => cell.set(value)
+    }
+  });
+  cell.set = () => undefined;
+  cell.update = update => cell.set(update(read()));
+  let readonly;
+  cell.asReadonly = () => readonly ??= createReadonlyCell(read);
+  return cell;
+};
+const createVueObservationAdapter = () => {
+  let invalidationGroupDepth = 0;
+  const pendingInvalidations = new Set();
+  const scheduleInvalidation = invalidate => {
+    if (invalidationGroupDepth > 0) {
+      pendingInvalidations.add(invalidate);
+      return;
+    }
+    invalidate();
+  };
+  const createObservationToken = () => {
+    const revision = shallowRef(0);
+    const invalidate = () => triggerRef(revision);
+    return {
+      observe: () => void revision.value,
+      invalidate: () => scheduleInvalidation(invalidate)
+    };
+  };
+  return {
+    createToken: createObservationToken,
+    createWritableCell: read => {
+      let published = read();
+      const revision = shallowRef(0);
+      const invalidate = () => triggerRef(revision);
+      return {
+        cell: createWritableCell(() => {
+          void revision.value;
+          return published;
+        }),
+        peek: read,
+        token: {
+          observe: () => void revision.value,
+          invalidate: () => {
+            published = read();
+            scheduleInvalidation(invalidate);
+          }
+        }
+      };
+    },
+    createWritableProjection: computeValue => ({
+      cell: createWritableCell(computeValue),
+      peek: computeValue
+    }),
+    createReadonlyCell: computeValue => {
+      const source = computed(computeValue);
+      return wrapReadonlyCell(source);
+    },
+    runInvalidationGroup(run) {
+      let failure;
+      let hasFailure = false;
+      invalidationGroupDepth += 1;
+      try {
+        run();
+      } catch (error) {
+        failure = error;
+        hasFailure = true;
+      } finally {
+        invalidationGroupDepth -= 1;
+        if (invalidationGroupDepth === 0 && pendingInvalidations.size > 0) {
+          const invalidations = [...pendingInvalidations];
+          pendingInvalidations.clear();
+          for (const invalidate of invalidations) {
+            try {
+              invalidate();
+            } catch (error) {
+              if (!hasFailure) {
+                failure = error;
+                hasFailure = true;
+              }
+            }
+          }
+        }
+      }
+      if (hasFailure) throw failure;
+    }
+  };
+};
+
+export { createVueObservationAdapter };

package/llms.txt

@@ -0,0 +1,177 @@
+# SignalTree
+
+SignalTree is framework-neutral reactive application state with causal
+semantics. The public v15 construction model is
+`signalTree(initialState, { derived, enhancers })`; state is read through
+`tree.$`.
+
+## What SignalTree is — and is not
+
+```text
+IS:     framework-independent consequential application state, stable subject
+      identity, authored versus external authority, coherent operation
+      boundaries, causal/restoration semantics, and link-based relationships
+
+IS NOT: primarily an undo library, event log, query library, sync engine, or
+      persistence framework
+```
+
+Undo/redo, event replay, query composition, live synchronization, and
+persistence are all things applications correctly BUILD on top of SignalTree's
+causal model — see "Composition patterns" below — but none of them is what
+SignalTree is FOR. Describe SignalTree by its primary job (consequential state
+with a causal model an application can trust), not by one thing that model
+happens to make easy.
+
+v15 ships four packages under the hyphenated `@signal-tree/*` scope (the pre-15
+`@signaltree/*` scope, no hyphen, stopped at 14.1.1):
+
+- `@signal-tree/kernel` — framework-neutral tree, `entityMap()`, causal turns,
+  links, and the `restoration()` / `transactions()` / `batching()` / `devTools()`
+  enhancers. Also `@signal-tree/kernel/adapter`, the realization SDK.
+- `@signal-tree/angular` — the complete Angular application facade. **Angular
+  code imports `signalTree` and all other SignalTree APIs from here**. Terminal
+  state leaves are native `WritableSignal<T>` values and derived leaves are
+  native `Signal<T>` values. Adds `defineStore()` and `toWritableSignal()` for
+  adapting callable object branches or designating form ingress.
+- `@signal-tree/react` — the complete React application facade. **React code
+  imports `signalTree`, markers, enhancers, and `useSignalTree(owner, selector)`
+  from here**; React observes the canonical kernel tree without copying it.
+- `@signal-tree/vue` — the complete Vue application facade. **Vue code imports
+  `signalTree` and all other SignalTree APIs from here**. Terminal state leaves
+  are native `Ref<T>` values and derived leaves are `ComputedRef<T>` values.
+
+Use `@signal-tree/kernel` directly only for framework-neutral TypeScript,
+including reusable domain libraries. Framework facades forward the neutral
+kernel surface by canonical identity; they do not duplicate semantic authority.
+
+## Accessor grammar and terminal values
+
+The neutral kernel exposes callable locations:
+
+```typescript
+location();                       // read
+location(nextValue);              // replace the complete value
+location((current) => nextValue); // derive the next complete value
+```
+
+The root (`tree.$`) and object branches keep this callable whole-value grammar
+in every facade. Terminal values use the framework's native carrier:
+
+```typescript
+angularTree.$.count();
+angularTree.$.count.set(5);
+angularTree.$.count.update((count) => count + 1);
+
+vueTree.$.count.value;
+vueTree.$.count.value = 5;
+```
+
+React has no persistent signal primitive, so `@signal-tree/react` keeps neutral
+locations and observes selected state through `useSignalTree(owner, selector)`.
+EntityMap query and field leaves follow the same carrier rule; EntityMap command
+methods such as `setAll()` and `updateOne()` do not change.
+
+Plain objects normally become traversable branches. `leaf(value)` explicitly
+ends topology so an object remains one atomic location. Callable values always
+use `leaf()` because a bare function argument is the updater syntax:
+
+```typescript
+const tree = signalTree({
+  range: leaf({ start: 0, end: 10 }),
+  callback: leaf((value: number) => console.log(value)),
+});
+
+angularTree.$.range.set({ start: 5, end: 15 });
+angularTree.$.callback.set((value) => persist(value));
+```
+
+The wrapper is consumed at construction or invocation and never enters state,
+snapshots, persistence, restoration, links, or causal payloads.
+
+There is no v15 forms, persistence, validation, events, or realtime package;
+those are application-owned. `.with()`, positional `derived`, and the
+`stored`/`asyncSource`/`asyncQuery`/`form`/`status` markers were all removed.
+
+## Migration Rule
+
+Never design SignalTree around a legacy application's intermediate state.
+
+1. Determine the canonical greenfield v15 architecture.
+2. Implement and validate that architecture independently.
+3. Migrate applications toward that target.
+4. Prefer deleting obsolete concepts over adapting them.
+5. Never add compatibility APIs merely to reduce migration work.
+6. A migration may falsify the target architecture, but legacy usage does not
+   define it.
+
+Do not create intermediate APIs intended to be removed later. Do not add
+compatibility layers because a migration is large. Do not preserve old
+ownership because moving it is inconvenient. Do not design framework adapters
+from legacy application idioms. Do not optimize for minimal migration diff.
+Optimize for the architecture applications should use five years from now.
+
+`@signal-tree/kernel/adapter` is the SDK for realization ownership, not a
+compatibility layer. New exports must be framework-neutral semantic facts owned
+by the kernel and required by correct realizations.
+
+## Framework Realization Rule
+
+Framework packages may realize SignalTree truth for their runtime. They must
+not create another state authority.
+
+Never use process-global mutable framework installation merely to make a legacy
+integration work if construction-bound ownership can express the long-term
+architecture. A migration cannot determine realization ownership.
+
+## Framework Ownership Ratchet
+
+`@signal-tree/kernel` owns framework-independent SignalTree semantics.
+`@signal-tree/kernel/adapter` owns only neutral ports for semantic questions
+the kernel owns. Framework packages own their implementations, lifecycle,
+diagnostics, schedulers, rendering behavior, primitive identity rules, and
+quirks. Neutral naming does not establish neutral ownership.
+
+Every new realization contract must state its SignalTree semantic job, provide
+a neutral implementation, be implementable by a tiny framework-free fake, and
+name the kernel authority deciding when and why it runs. Reject contracts that
+exist only for one framework. If Angular, React, and Vue disappeared, the
+contract must remain meaningful to SignalTree or another reactive runtime.
+
+## Composition patterns
+
+Several capabilities that look like missing features are compositions of
+primitives that already ship — see `docs/guides/composition-recipes.md` for
+the full recipes with executable-spec citations. Do not propose a new marker
+or kernel API for any of these before reading it:
+
+- a standard enhancer policy, a reusable entity-CRUD Ops base, a selection
+  read-model
+- optimistic writes with server reconciliation (`transactions()`'s
+  pending/confirm/rollback lifecycle)
+- staged/draft editing (an application-owned draft, one authored commit — no
+  `beginStage()` session API)
+- one-shot loading (`external()`, no `link()` needed for a single fetch) versus
+  a persistent relationship with an external authority (`link()`'s three
+  composable directions: PULL/PUSH-IN/PUSH-OUT)
+- accepted external truth is distinct from authored application work, so an
+  external write is not automatically a retained causal-history turn
+- a human-readable explanation projected from the causal record (the
+  explanation is a PROJECTION of causal truth — the kernel does not store
+  prose, actor names, or timestamps merely to make one convenient)
+
+`docs/guides/persistence-guide.md` is the `link()`-as-storage specialization
+of the same model.
+
+## Canonical Sources
+
+- `AGENTS.md` — contributor and consumer rules
+- `RELEASE-1.0.md` — v15 release invariants and current release state
+- `README.md` — public package overview
+- `packages/kernel/README.md` — kernel API and examples
+- `packages/angular/README.md` — Angular realization
+- `packages/react/README.md` — React observation
+- `docs/guides/composition-recipes.md` — patterns built from existing primitives, no new API
+- `docs/guides/persistence-guide.md` — the `link()`-as-storage recipe
+- `docs/guides/migration-v14-v15.md` — `@signaltree/*` → `@signal-tree/*` migration (rename, consolidation, removed APIs)
+- `docs/migration/post-rc1-workstream.md` — greenfield-first post-RC program

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@signal-tree/vue",
+  "version": "15.0.0-rc.14",
+  "description": "Vue observation for SignalTree.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/**/*.js",
+    "src/**/*.d.ts",
+    "README.md",
+    "LICENSE",
+    "NOTICE",
+    "llms.txt"
+  ],
+  "dependencies": {
+    "@signal-tree/kernel": "15.0.0-rc.14"
+  },
+  "peerDependencies": {
+    "tslib": "^2.0.0",
+    "vue": "^3.5.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JBorgia/signal-tree.git",
+    "directory": "packages/vue"
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `@signal-tree/vue` provides Vue-native refs over kernel-owned state.
+ *
+ * Values, writes, equality, and causal semantics remain kernel-owned.
+ *
+ * @packageDocumentation
+ */
+import './lib/carrier.js';
+import { type AccessibleNodeOf, type EntityNodeOf, type EntitySignalOf, type EntitySignalWithSlicesOf, type ISignalTreeOf, type LeafOf, type ReadonlyStoreOf, type ReadonlyViewOf, type SignalTreeFactoryOf, type TreeNodeOf } from '@signal-tree/kernel/adapter';
+/** Construct a SignalTree whose leaves are native Vue refs. */
+export declare const signalTree: SignalTreeFactoryOf<"vue">;
+export type TreeNode<T> = TreeNodeOf<T, 'vue'>;
+export type WritableLeaf<T> = LeafOf<T, 'vue'>;
+export type AccessibleNode<T> = AccessibleNodeOf<T, 'vue'>;
+export type ISignalTree<T, TAccum = TreeNode<T>> = ISignalTreeOf<T, 'vue', TAccum>;
+export type SignalTree<T> = ISignalTree<T>;
+export type EntityNode<E> = EntityNodeOf<E, 'vue'>;
+export type EntitySignal<E, K extends string | number = string> = EntitySignalOf<E, K, 'vue'>;
+export type EntitySignalWithSlices<E, K extends string | number, Slices extends Record<string, unknown>> = EntitySignalWithSlicesOf<E, K, Slices, 'vue'>;
+export type ReadonlyView<T> = ReadonlyViewOf<T, 'vue'>;
+export type ReadonlyStore<TSource, TAccum = TreeNode<TSource>> = ReadonlyStoreOf<TSource, TAccum, 'vue'>;
+export declare const asReadonly: <TSource, TAccum>(tree: ISignalTreeOf<TSource, "vue", TAccum>) => ReadonlyStoreOf<TSource, TAccum, "vue">;
+export * from '@signal-tree/kernel';

package/src/lib/carrier.d.ts

@@ -0,0 +1,13 @@
+import type { ComputedRef, Ref } from 'vue';
+export type VueLeaf<T> = Ref<T>;
+declare module '@signal-tree/kernel/adapter' {
+    interface LeafCarriers<T> {
+        vue: VueLeaf<T>;
+    }
+    interface ReadonlyLeafCarriers<T> {
+        vue: ComputedRef<T>;
+    }
+    interface ReadonlyViewLeafCarriers<T> {
+        vue: Readonly<Ref<T>>;
+    }
+}

package/src/lib/vue-observation.d.ts

@@ -0,0 +1,2 @@
+import type { ObservationAdapter } from '@signal-tree/kernel/adapter';
+export declare const createVueObservationAdapter: () => ObservationAdapter;