@atscript/vue-wf 0.1.58

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Artem Maltsev <artem@maltsev.nl>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,23 @@
+# @atscript/vue-wf
+
+Vue 3 client for the atscript-ui workflow form — HTTP round-trip loop driven by metadata exchanged with a [`@atscript/moost-wf`](../moost-wf) server.
+
+Part of the [atscript-ui](https://github.com/moostjs/atscript-ui) monorepo.
+
+## What it provides
+
+- `<AsWfForm>` — single component that drives the full workflow: posts current state, renders the next step's form, validates with the schema returned by the server, and resumes after pauses
+- Hooks for custom transport, error display, and per-step UI overrides
+- Built on [`@atscript/vue-form`](../vue-form), so all form-rendering primitives (field types, default renderers, layout grid) carry over
+
+## Install
+
+```sh
+pnpm add @atscript/vue-wf
+```
+
+Peer requirements: `vue@^3`, `@atscript/vue-form`, `@atscript/typescript`.
+
+## License
+
+MIT © Artem Maltsev

package/dist/as-wf-form-CBBvLmgY.mjs

@@ -0,0 +1,350 @@
+import { computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, defineComponent, guardReactiveProps, normalizeProps, onMounted, onUnmounted, openBlock, reactive, ref, renderSlot, shallowRef, toDisplayString, toRaw, unref, watch, withCtx } from "vue";
+import { WF_ACTION_WITH_DATA, createFormData, createFormDef, getFieldMeta } from "@atscript/ui";
+import { deserializeAnnotatedType } from "@atscript/typescript/utils";
+import { AsForm } from "@atscript/vue-form";
+//#region src/use-wf-form.ts
+function useWfForm(options) {
+	const tokenName = options.tokenName ?? "wfs";
+	const wfidName = options.wfidName ?? "wfid";
+	const transport = options.tokenTransport ?? "body";
+	const formDef = shallowRef(null);
+	const formData = shallowRef(null);
+	const formContext = shallowRef({});
+	const errors = shallowRef({});
+	const response = shallowRef(null);
+	const error = shallowRef(null);
+	const loading = ref(false);
+	const finished = ref(false);
+	/** Increments each time the form schema changes — used as :key on AsForm to force remount. */
+	const formKey = ref(0);
+	let token;
+	let lastRequestBody;
+	let lastPayloadJson;
+	let abortController;
+	const { headers: extraHeaders, ...restFetchOpts } = options.fetchOptions ?? {};
+	const baseFetchOpts = {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...extraHeaders instanceof Headers ? Object.fromEntries(extraHeaders) : Array.isArray(extraHeaders) ? Object.fromEntries(extraHeaders) : extraHeaders
+		},
+		...transport === "cookie" ? { credentials: "include" } : {},
+		...restFetchOpts
+	};
+	function readInitialToken() {
+		if (options.initialToken) return options.initialToken;
+		if (transport === "query") return new URLSearchParams(window.location.search).get(tokenName) ?? void 0;
+	}
+	function buildBody(payload) {
+		const body = { ...payload };
+		if (transport !== "cookie" && token) body[tokenName] = token;
+		return body;
+	}
+	function extractToken(data) {
+		if (transport !== "cookie" && tokenName in data) token = data[tokenName];
+	}
+	function processResponse(data) {
+		extractToken(data);
+		if (data.finished) {
+			finished.value = true;
+			response.value = data;
+			formDef.value = null;
+			formData.value = null;
+			lastPayloadJson = void 0;
+			return;
+		}
+		if (data.sent === true || typeof data.outlet === "string") {
+			finished.value = true;
+			response.value = data;
+			formDef.value = null;
+			formData.value = null;
+			lastPayloadJson = void 0;
+			return;
+		}
+		if (data.error) {
+			error.value = data.error;
+			return;
+		}
+		const ir = data.inputRequired;
+		if (!ir) {
+			error.value = { message: "Unexpected response format" };
+			return;
+		}
+		const { errors: serverErrors, ...remainingCtx } = ir.context ?? {};
+		const payloadJson = JSON.stringify(ir.payload);
+		if (payloadJson !== lastPayloadJson) {
+			lastPayloadJson = payloadJson;
+			formKey.value++;
+			const type = deserializeAnnotatedType(ir.payload);
+			formDef.value = createFormDef(type);
+			formData.value = reactive(createFormData(type));
+		}
+		formContext.value = remainingCtx;
+		errors.value = serverErrors ?? {};
+		finished.value = false;
+		error.value = null;
+	}
+	async function post(body) {
+		abortController?.abort();
+		abortController = new AbortController();
+		const { signal } = abortController;
+		loading.value = true;
+		error.value = null;
+		lastRequestBody = body;
+		try {
+			const res = await (options.fetch ?? fetch)(options.path, {
+				...baseFetchOpts,
+				signal,
+				body: JSON.stringify(buildBody(body))
+			});
+			if (!res.ok) {
+				error.value = {
+					message: (await res.json().catch(() => ({ message: res.statusText }))).message ?? res.statusText,
+					status: res.status
+				};
+				return;
+			}
+			processResponse(await res.json());
+		} catch (err) {
+			if (err instanceof DOMException && err.name === "AbortError") return;
+			error.value = { message: err instanceof Error ? err.message : "Network error" };
+		} finally {
+			loading.value = false;
+		}
+	}
+	async function start(input) {
+		const initialToken = readInitialToken();
+		if (initialToken) token = initialToken;
+		const body = { [wfidName]: options.name };
+		if (input) body.input = input;
+		if (initialToken) body[tokenName] = initialToken;
+		await post(body);
+	}
+	async function submit(data) {
+		await post({ input: data });
+	}
+	async function action(name) {
+		await post({ action: name });
+	}
+	async function actionWithData(name, data) {
+		await post({
+			input: data,
+			action: name
+		});
+	}
+	async function retry() {
+		if (lastRequestBody) await post(lastRequestBody);
+	}
+	if (options.autoStart !== false) onMounted(() => start(options.input));
+	onUnmounted(() => abortController?.abort());
+	return {
+		formDef,
+		formData,
+		formContext,
+		errors,
+		formKey,
+		loading,
+		finished,
+		response,
+		error,
+		start,
+		submit,
+		action,
+		actionWithData,
+		retry
+	};
+}
+//#endregion
+//#region src/components/as-wf-form.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = { key: 0 };
+const _hoisted_2 = { key: 1 };
+const _hoisted_3 = { key: 2 };
+const _hoisted_4 = { key: 3 };
+const _hoisted_5 = {
+	role: "alert",
+	class: "as-wf-form-error"
+};
+const _hoisted_6 = ["disabled"];
+//#endregion
+//#region src/components/as-wf-form.vue
+var as_wf_form_default = /* @__PURE__ */ defineComponent({
+	__name: "as-wf-form",
+	props: {
+		types: {
+			type: Object,
+			required: true
+		},
+		firstValidation: {
+			type: String,
+			required: false
+		},
+		components: {
+			type: Object,
+			required: false
+		},
+		clientFactory: {
+			type: Function,
+			required: false
+		},
+		path: {
+			type: String,
+			required: true
+		},
+		name: {
+			type: String,
+			required: true
+		},
+		input: {
+			type: Object,
+			required: false
+		},
+		tokenTransport: {
+			type: String,
+			required: false,
+			default: "body"
+		},
+		tokenName: {
+			type: String,
+			required: false,
+			default: "wfs"
+		},
+		wfidName: {
+			type: String,
+			required: false,
+			default: "wfid"
+		},
+		fetchOptions: {
+			type: null,
+			required: false
+		},
+		fetch: {
+			type: null,
+			required: false
+		},
+		autoStart: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		initialToken: {
+			type: String,
+			required: false
+		}
+	},
+	emits: [
+		"finished",
+		"error",
+		"form",
+		"submit",
+		"loading"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const wf = useWfForm(props);
+		watch(() => wf.loading.value, (v) => emit("loading", v));
+		watch(() => wf.finished.value, (v) => {
+			if (v) emit("finished", wf.response.value);
+		});
+		watch(() => wf.error.value, (v) => {
+			if (v) emit("error", v);
+		});
+		watch([() => wf.formDef.value, () => wf.formContext.value], ([def, ctx]) => {
+			if (def) emit("form", def, ctx);
+		});
+		const withDataActions = computed(() => {
+			const def = wf.formDef.value;
+			if (!def) return /* @__PURE__ */ new Set();
+			const set = /* @__PURE__ */ new Set();
+			for (const field of def.fields) {
+				const wfAction = getFieldMeta(field.prop, WF_ACTION_WITH_DATA);
+				if (wfAction) set.add(wfAction);
+			}
+			return set;
+		});
+		function onSubmit(data) {
+			const raw = toRaw(data);
+			emit("submit", raw);
+			wf.submit(raw);
+		}
+		function onAction(name, data) {
+			if (withDataActions.value.has(name)) wf.actionWithData(name, toRaw(data));
+			else wf.action(name);
+		}
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", {
+				form: {
+					def: unref(wf).formDef.value,
+					formData: unref(wf).formData.value,
+					formContext: unref(wf).formContext.value
+				},
+				state: {
+					loading: unref(wf).loading.value,
+					error: unref(wf).error.value,
+					finished: unref(wf).finished.value,
+					response: unref(wf).response.value
+				},
+				actions: {
+					start: unref(wf).start,
+					submit: onSubmit,
+					retry: unref(wf).retry
+				}
+			}, () => [unref(wf).loading.value && !unref(wf).formDef.value ? (openBlock(), createElementBlock("div", _hoisted_1, [renderSlot(_ctx.$slots, "wf.loading")])) : unref(wf).error.value && !unref(wf).formDef.value ? (openBlock(), createElementBlock("div", _hoisted_2, [renderSlot(_ctx.$slots, "wf.error", {
+				error: unref(wf).error.value,
+				retry: unref(wf).retry
+			}, () => [createElementVNode("div", null, toDisplayString(unref(wf).error.value?.message ?? "Error"), 1)])])) : unref(wf).finished.value ? (openBlock(), createElementBlock("div", _hoisted_3, [renderSlot(_ctx.$slots, "wf.finished", { response: unref(wf).response.value })])) : unref(wf).formDef.value && unref(wf).formData.value ? (openBlock(), createElementBlock("div", _hoisted_4, [unref(wf).error.value ? renderSlot(_ctx.$slots, "form.error", {
+				key: 0,
+				error: unref(wf).error.value,
+				retry: unref(wf).retry
+			}, () => [createElementVNode("div", _hoisted_5, toDisplayString(unref(wf).error.value?.message ?? "Error"), 1)]) : createCommentVNode("v-if", true), (openBlock(), createBlock(unref(AsForm), {
+				key: unref(wf).formKey.value,
+				def: unref(wf).formDef.value,
+				"form-data": unref(wf).formData.value,
+				types: __props.types,
+				errors: unref(wf).errors.value,
+				"form-context": unref(wf).formContext.value,
+				"first-validation": __props.firstValidation,
+				components: __props.components,
+				"client-factory": __props.clientFactory,
+				loading: unref(wf).loading.value,
+				onSubmit,
+				onAction,
+				onUnsupportedAction: onAction
+			}, {
+				"form.header": withCtx((slotProps) => [renderSlot(_ctx.$slots, "form.header", normalizeProps(guardReactiveProps({
+					...slotProps,
+					loading: unref(wf).loading.value
+				})))]),
+				"form.before": withCtx((slotProps) => [renderSlot(_ctx.$slots, "form.before", normalizeProps(guardReactiveProps({
+					...slotProps,
+					loading: unref(wf).loading.value
+				})))]),
+				"form.after": withCtx((slotProps) => [renderSlot(_ctx.$slots, "form.after", normalizeProps(guardReactiveProps({
+					...slotProps,
+					loading: unref(wf).loading.value
+				})))]),
+				"form.submit": withCtx((slotProps) => [renderSlot(_ctx.$slots, "form.submit", normalizeProps(guardReactiveProps({
+					...slotProps,
+					loading: unref(wf).loading.value
+				})), () => [createElementVNode("button", { disabled: slotProps.disabled || unref(wf).loading.value }, toDisplayString(slotProps.text), 9, _hoisted_6)])]),
+				"form.footer": withCtx((slotProps) => [renderSlot(_ctx.$slots, "form.footer", normalizeProps(guardReactiveProps({
+					...slotProps,
+					loading: unref(wf).loading.value
+				})))]),
+				_: 3
+			}, 8, [
+				"def",
+				"form-data",
+				"types",
+				"errors",
+				"form-context",
+				"first-validation",
+				"components",
+				"client-factory",
+				"loading"
+			]))])) : createCommentVNode("v-if", true)]);
+		};
+	}
+});
+//#endregion
+export { useWfForm as n, as_wf_form_default as t };

package/dist/as-wf-form.d.mts

@@ -0,0 +1,2 @@
+import { t as _default } from "./as-wf-form.vue-BP739hjJ.mjs";
+export { _default as default };

package/dist/as-wf-form.mjs

@@ -0,0 +1,2 @@
+import { t as as_wf_form_default } from "./as-wf-form-CBBvLmgY.mjs";
+export { as_wf_form_default as default };

package/dist/as-wf-form.vue-BP739hjJ.d.mts

@@ -0,0 +1,190 @@
+import * as vue from "vue";
+import { Component, Ref, ShallowRef } from "vue";
+import { ClientFactory, FormDef } from "@atscript/ui";
+import { TAsTypeComponents, TFormState } from "@atscript/vue-form";
+
+//#region src/use-wf-form.d.ts
+interface UseWfFormOptions {
+  /** HTTP endpoint for the workflow trigger (e.g., '/api/auth/flow') */
+  path: string;
+  /** Workflow ID to start (e.g., 'auth/login') */
+  name: string;
+  /** Initial input to send with the start request */
+  input?: Record<string, unknown>;
+  /**
+   * How to transport the workflow state token.
+   * - 'body' (default): token travels in request/response JSON body
+   * - 'cookie': token travels via Set-Cookie / Cookie headers
+   * - 'query': token is read from URL query params (for email magic links)
+   */
+  tokenTransport?: "body" | "cookie" | "query";
+  /** Token parameter name (default: 'wfs') */
+  tokenName?: string;
+  /** Workflow ID parameter name (default: 'wfid') */
+  wfidName?: string;
+  /** Custom fetch options (headers, credentials, etc.) */
+  fetchOptions?: RequestInit;
+  /**
+   * Override the global `fetch` — lets the host wire its own status-code
+   * bus or interceptors (e.g. a wrapper that emits on `on410` so the app's
+   * expiry banner lights up). Defaults to `globalThis.fetch`.
+   */
+  fetch?: typeof fetch;
+  /** Whether to auto-start the workflow on mount (default: true) */
+  autoStart?: boolean;
+  /**
+   * Pre-existing workflow state token to resume from. Use when the token lives
+   * outside `window.location.search` — e.g. encoded in a Vue Router path param
+   * (`/invite/:token`) or pulled from app state. Included in the first request
+   * so the server resumes the paused workflow instead of starting a new one.
+   * Takes precedence over `tokenTransport: "query"` auto-detection.
+   */
+  initialToken?: string;
+}
+interface UseWfFormReturn {
+  formDef: ShallowRef<FormDef | null>;
+  formData: ShallowRef<Record<string, unknown> | null>;
+  formContext: ShallowRef<Record<string, unknown>>;
+  errors: ShallowRef<Record<string, string>>;
+  /** Increments each time the form schema changes — use as :key on AsForm to force remount. */
+  formKey: Ref<number>;
+  loading: Ref<boolean>;
+  finished: Ref<boolean>;
+  response: ShallowRef<unknown>;
+  error: ShallowRef<unknown>;
+  start: (input?: Record<string, unknown>) => Promise<void>;
+  submit: (data: unknown) => Promise<void>;
+  action: (name: string) => Promise<void>;
+  actionWithData: (name: string, data: unknown) => Promise<void>;
+  retry: () => Promise<void>;
+}
+declare function useWfForm(options: UseWfFormOptions): UseWfFormReturn;
+//#endregion
+//#region src/components/as-wf-form.vue.d.ts
+interface AsWfFormProps extends UseWfFormOptions {
+  /** Type-to-component map for AsForm rendering */
+  types: TAsTypeComponents;
+  /** First validation strategy passed to AsForm */
+  firstValidation?: TFormState["firstValidation"];
+  /** Custom components map passed to AsForm */
+  components?: Record<string, Component>;
+  /** Per-form client factory override (FK value-help). Forwarded to AsForm. */
+  clientFactory?: ClientFactory;
+}
+declare function onSubmit(data: unknown): void;
+declare var __VLS_1: {
+    form: {
+      def: FormDef | null;
+      formData: Record<string, unknown> | null;
+      formContext: Record<string, unknown>;
+    };
+    state: {
+      loading: boolean;
+      error: unknown;
+      finished: boolean;
+      response: unknown;
+    };
+    actions: {
+      start: (input?: Record<string, unknown>) => Promise<void>;
+      submit: typeof onSubmit;
+      retry: () => Promise<void>;
+    };
+  }, __VLS_3: {}, __VLS_5: {
+    error: {};
+    retry: () => Promise<void>;
+  }, __VLS_7: {
+    response: unknown;
+  }, __VLS_9: {
+    error: {};
+    retry: () => Promise<void>;
+  }, __VLS_22: {
+    loading: boolean;
+    clearErrors: () => void;
+    reset: () => Promise<void>;
+    setErrors: (errors: Record<string, string>) => void;
+    formContext: Record<string, unknown> | undefined;
+    disabled: boolean;
+  }, __VLS_25: {
+    loading: boolean;
+    clearErrors: () => void;
+    reset: () => Promise<void>;
+    setErrors: (errors: Record<string, string>) => void;
+    formContext: Record<string, unknown> | undefined;
+    disabled: boolean;
+  }, __VLS_28: {
+    loading: boolean;
+    clearErrors: () => void;
+    reset: () => Promise<void>;
+    setErrors: (errors: Record<string, string>) => void;
+    disabled: boolean;
+    formContext: Record<string, unknown> | undefined;
+  }, __VLS_31: {
+    loading: boolean;
+    disabled: boolean;
+    text: string;
+    clearErrors: () => void;
+    reset: () => Promise<void>;
+    setErrors: (errors: Record<string, string>) => void;
+    formContext: Record<string, unknown> | undefined;
+  }, __VLS_34: {
+    loading: boolean;
+    disabled: boolean;
+    clearErrors: () => void;
+    reset: () => Promise<void>;
+    setErrors: (errors: Record<string, string>) => void;
+    formContext: Record<string, unknown> | undefined;
+  };
+type __VLS_Slots = {} & {
+  default?: (props: typeof __VLS_1) => any;
+} & {
+  'wf.loading'?: (props: typeof __VLS_3) => any;
+} & {
+  'wf.error'?: (props: typeof __VLS_5) => any;
+} & {
+  'wf.finished'?: (props: typeof __VLS_7) => any;
+} & {
+  'form.error'?: (props: typeof __VLS_9) => any;
+} & {
+  'form.header'?: (props: typeof __VLS_22) => any;
+} & {
+  'form.before'?: (props: typeof __VLS_25) => any;
+} & {
+  'form.after'?: (props: typeof __VLS_28) => any;
+} & {
+  'form.submit'?: (props: typeof __VLS_31) => any;
+} & {
+  'form.footer'?: (props: typeof __VLS_34) => any;
+};
+declare const __VLS_base: vue.DefineComponent<AsWfFormProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {} & {
+  finished: (response: unknown) => any;
+  error: (error: {
+    message: string;
+    status?: number;
+  }) => any;
+  submit: (data: unknown) => any;
+  loading: (isLoading: boolean) => any;
+  form: (def: FormDef, context?: Record<string, unknown> | undefined) => any;
+}, string, vue.PublicProps, Readonly<AsWfFormProps> & Readonly<{
+  onFinished?: ((response: unknown) => any) | undefined;
+  onError?: ((error: {
+    message: string;
+    status?: number;
+  }) => any) | undefined;
+  onSubmit?: ((data: unknown) => any) | undefined;
+  onLoading?: ((isLoading: boolean) => any) | undefined;
+  onForm?: ((def: FormDef, context?: Record<string, unknown> | undefined) => any) | undefined;
+}>, {
+  tokenTransport: "body" | "cookie" | "query";
+  tokenName: string;
+  wfidName: string;
+  autoStart: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+export { useWfForm as i, UseWfFormOptions as n, UseWfFormReturn as r, _default as t };

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+import { i as useWfForm, n as UseWfFormOptions, r as UseWfFormReturn, t as _default } from "./as-wf-form.vue-BP739hjJ.mjs";
+export { _default as AsWfForm, type UseWfFormOptions, type UseWfFormReturn, useWfForm };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { n as useWfForm, t as as_wf_form_default } from "./as-wf-form-CBBvLmgY.mjs";
+export { as_wf_form_default as AsWfForm, useWfForm };

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@atscript/vue-wf",
+  "version": "0.1.58",
+  "description": "Workflow form integration for Vue 3 — HTTP round-trip loop driven by atscript type metadata",
+  "keywords": [
+    "atscript",
+    "form",
+    "metadata",
+    "moost",
+    "type-driven",
+    "typescript",
+    "vue",
+    "vue3",
+    "wf",
+    "workflow"
+  ],
+  "homepage": "https://github.com/moostjs/atscript-ui/tree/main/packages/vue-wf#readme",
+  "bugs": {
+    "url": "https://github.com/moostjs/atscript-ui/issues"
+  },
+  "license": "MIT",
+  "author": "Artem Maltsev <artem@maltsev.nl>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moostjs/atscript-ui.git",
+    "directory": "packages/vue-wf"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./as-wf-form": {
+      "types": "./dist/as-wf-form.d.mts",
+      "import": "./dist/as-wf-form.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@atscript/ui": "^0.1.58"
+  },
+  "devDependencies": {
+    "@atscript/core": "^0.1.54",
+    "@atscript/typescript": "^0.1.54",
+    "@vitejs/plugin-vue": "^6",
+    "@vue/test-utils": "^2",
+    "happy-dom": "^18",
+    "unplugin-atscript": "^0.1.54",
+    "vitest": "npm:@voidzero-dev/vite-plus-test@latest",
+    "vue": "^3",
+    "vue-tsc": "^3.2.6",
+    "@atscript/moost-wf": "^0.1.58",
+    "@atscript/vue-form": "^0.1.58"
+  },
+  "peerDependencies": {
+    "@atscript/typescript": "^0.1.54",
+    "vue": "^3",
+    "@atscript/vue-form": "^0.1.58"
+  },
+  "scripts": {
+    "build": "node ../../scripts/gen-exports.mjs && vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check"
+  }
+}