@poveste/plugin-svelte 0.10.0 → 0.12.0

package/auto-props.d.ts

@@ -0,0 +1,2 @@
+// https://github.com/microsoft/TypeScript/issues/33079
+export * from './dist/client/auto-props'

package/dist/client/RenderVariant.js

@@ -1 +1 @@
-import{watch as e}from"@poveste/vendors/vue";import{getContext as t,onDestroy as n}from"svelte";import"svelte/internal/disclose-version";import"svelte/internal/flags/legacy";import*as r from"svelte/internal/client";var i=r.from_html(`<!> <!>`,1);function a(a,o){let s=r.sanitize_slots(o);r.push(o,!1);let c=t(`__pvtStory`),l=r.mutable_source(t(`__pvtVariant`)),u=t(`__pvtSlot`),d=t(`__pvtIndex`),f=c.variants[d.value];d.value++;let p=r.get(l).id===f.id,m=r.prop(o,`source`,8,null),h=r.prop(o,`initState`,8,null);h()&&p&&!r.get(l).__pvtStateSeeded&&(r.mutate(l,r.get(l).__pvtStateSeeded=!0),r.mutate(l,r.get(l).state={...r.get(l).state,...h()()})),!h()&&p&&u===`controls`&&s.controls&&!r.get(l).__pvtStateWarned&&(r.mutate(l,r.get(l).__pvtStateWarned=!0),console.error([`[poveste] Variant "${f?.title??f?.id}" has a controls slot but no \`initState\`.`,`Controls will render and appear to work, but their edits cannot reach the story:`,`the story is mounted separately for each slot, so a component-local variable is not shared.`,"Pass `initState` and read state from the snippet —",`https://poveste.dev/guide/migration-from-histoire.html#svelte-story-state-moves-to-initstate`].join(` `)));let g=r.mutable_source(r.get(l)?.state),_=()=>{};p&&(_=e(()=>r.get(l)?.state,()=>{r.set(g,r.get(l)?.state)},{deep:!0})),n(()=>_()),r.legacy_pre_effect(()=>(r.deep_read_state(m()),r.get(g),r.get(l)),()=>{if(p){let e=typeof m()==`function`?m()(r.get(g)):m();e!=null&&Object.assign(r.get(l),{source:e})}}),r.legacy_pre_effect_reset(),r.init();var v=r.comment(),y=r.first_child(v),b=e=>{var t=i(),n=r.first_child(t),a=e=>{var t=r.comment(),n=r.first_child(t);r.slot(n,o,`default`,{get state(){return r.get(g)}},null),r.append(e,t)};r.if(n,e=>{u==="default"&&e(a)});var s=r.sibling(n,2),c=e=>{var t=r.comment(),n=r.first_child(t);r.slot(n,o,`controls`,{get state(){return r.get(g)}},null),r.append(e,t)};r.if(s,e=>{u===`controls`&&e(c)}),r.append(e,t)};r.if(y,e=>{p&&e(b)}),r.append(a,v),r.pop()}export{a as default};
+import{shouldWarnAboutMissingInitState as e}from"../util/init-state-warning.js";import{watch as t}from"@poveste/vendors/vue";import{getContext as n,onDestroy as r}from"svelte";import"svelte/internal/disclose-version";import"svelte/internal/flags/legacy";import*as i from"svelte/internal/client";var a=i.from_html(`<!> <!>`,1);function o(o,s){let c=i.sanitize_slots(s);i.push(s,!1);let l=n(`__pvtStory`),u=i.mutable_source(n(`__pvtVariant`)),d=n(`__pvtSlot`),f=n(`__pvtIndex`),p=l.variants[f.value];f.value++;let m=i.get(u).id===p.id,h=i.prop(s,`source`,8,null),g=i.prop(s,`initState`,8,null);g()&&m&&!i.get(u).__pvtStateSeeded&&(i.mutate(u,i.get(u).__pvtStateSeeded=!0),i.mutate(u,i.get(u).state={...i.get(u).state,...g()()})),m&&e({hasInitState:!!g(),seeded:!!i.get(u).__pvtStateSeeded,slotName:d,hasControlsSlot:!!c.controls,alreadyWarned:!!i.get(u).__pvtStateWarned})&&(i.mutate(u,i.get(u).__pvtStateWarned=!0),console.error([`[poveste] Variant "${p?.title??p?.id}" has a controls slot but no \`initState\`.`,`Controls will render and appear to work, but their edits cannot reach the story:`,`the story is mounted separately for each slot, so a component-local variable is not shared.`,"Pass `initState` and read state from the snippet —",`https://poveste.dev/guide/migration-from-histoire.html#svelte-story-state-moves-to-initstate`].join(` `)));let _=i.mutable_source(i.get(u)?.state),v=()=>{};m&&(v=t(()=>i.get(u)?.state,()=>{i.set(_,i.get(u)?.state)},{deep:!0})),r(()=>v()),i.legacy_pre_effect(()=>(i.deep_read_state(h()),i.get(_),i.get(u)),()=>{if(m){let e=typeof h()==`function`?h()(i.get(_)):h();e!=null&&Object.assign(i.get(u),{source:e})}}),i.legacy_pre_effect_reset(),i.init();var y=i.comment(),b=i.first_child(y),x=e=>{var t=a(),n=i.first_child(t),r=e=>{var t=i.comment(),n=i.first_child(t);i.slot(n,s,`default`,{get state(){return i.get(_)}},null),i.append(e,t)};i.if(n,e=>{d==="default"&&e(r)});var o=i.sibling(n,2),c=e=>{var t=i.comment(),n=i.first_child(t);i.slot(n,s,`controls`,{get state(){return i.get(_)}},null),i.append(e,t)};i.if(o,e=>{d===`controls`&&e(c)}),i.append(e,t)};i.if(b,e=>{m&&e(x)}),i.append(o,y),i.pop()}export{o as default};

package/dist/client/RenderVariant.svelte

@@ -1,6 +1,7 @@
 <script>
   import { watch as _watch } from '@poveste/vendors/vue'
   import { getContext, onDestroy } from 'svelte'
+  import { shouldWarnAboutMissingInitState } from '../util/init-state-warning.js'
 
   const story = getContext('__pvtStory')
   const currentVariant = getContext('__pvtVariant')
@@ -27,9 +28,13 @@
     currentVariant.state = { ...currentVariant.state, ...initState() }
   }
 
-  // Controls mount only — see the note in RenderStory: the two mounts do not share
-  // a realm for iframe layouts, so this is what keeps it to one warning.
-  if (!initState && shouldRender && slotName === 'controls' && $$slots.controls && !currentVariant.__pvtStateWarned) {
+  if (shouldRender && shouldWarnAboutMissingInitState({
+    hasInitState: Boolean(initState),
+    seeded: Boolean(currentVariant.__pvtStateSeeded),
+    slotName,
+    hasControlsSlot: Boolean($$slots.controls),
+    alreadyWarned: Boolean(currentVariant.__pvtStateWarned),
+  })) {
     currentVariant.__pvtStateWarned = true
     console.error([
       `[poveste] Variant "${variant?.title ?? variant?.id}" has a controls slot but no \`initState\`.`,

package/dist/client/auto-props.d.ts

@@ -0,0 +1,14 @@
+import type { AutoPropComponentDefinition } from '@poveste/shared';
+type Values = Record<string, any>[][];
+/**
+ * Publishes what the panel renders (`_hPropDefs`) and returns a store of what
+ * the reader has set, which the rewritten markup spreads onto each component.
+ */
+export declare function autoProps(defs: AutoPropComponentDefinition[][]): import("svelte/store").Readable<Values>;
+/**
+ * Which variant's controls this realm answers to, or -1 for none. The story's
+ * own `autoPropsDisabled` is read directly, because story props reach only an
+ * implicit variant (#466).
+ */
+export declare function variantToDrive(story: any, variant: any): number;
+export {};

package/dist/client/auto-props.js

@@ -0,0 +1 @@
+import{watch as e}from"@poveste/vendors/vue";import{readable as t}from"svelte/store";import{applyState as n}from"@poveste/shared";import{getContext as r}from"svelte";var i=Object.freeze({});function a(a){let l=r(`__pvtStory`),u=r(`__pvtVariant`),d=c(l,u),f=a.map(e=>Array.from({length:s(e)}).fill(i));if(d<0)return o(u),t(f);let p=a[d]??[],m=()=>{let e=f.slice();return e[d]=Array.from({length:s(p)},(e,t)=>u.state?._hPropState?.[t]??i),e},h=null;function g(){!u.state||h===u.state&&u.state._hPropDefs?.length||(h=u.state,n(u.state,{_hPropDefs:p}),u.state._hPropState||n(u.state,{_hPropState:{}}))}return t(m(),t=>{let n=()=>{g(),t(m())};n();let r=[e(()=>u.state,n),e(()=>u.state?._hPropState,n,{deep:!0}),e(()=>u.state?._hPropDefs?.length,n)];return()=>r.forEach(e=>e())})}function o(e){e?.state?._hPropDefs?.length&&n(e.state,{_hPropDefs:[]})}function s(e){return e.reduce((e,t)=>Math.max(e,t.index+1),0)}function c(e,t){return!e||!t||e.autoPropsDisabled||t.autoPropsDisabled?-1:e.variants?.findIndex(e=>e.id===t.id)??-1}export{a as autoProps,c as variantToDrive};

package/dist/collect/Story.js

@@ -1 +1 @@
-import{getContext as e,setContext as t}from"svelte";import"svelte/internal/disclose-version";import"svelte/internal/flags/legacy";import*as n from"svelte/internal/client";function r(r,i){n.push(i,!1);let a=n.prop(i,`title`,8,null),o=n.prop(i,`id`,8,null),s=n.prop(i,`group`,8,null),c=n.prop(i,`layout`,8,null),l=n.prop(i,`icon`,8,null),u=n.prop(i,`iconColor`,8,null),d=n.prop(i,`docsOnly`,8,!1),f=n.prop(i,`initState`,8,null),p=e(`__pvtAddStory`),m=e(`__pvtStoryFile`),h={id:o()??m.id,title:a()??m.fileName,group:s(),layout:c(),icon:l(),iconColor:u(),docsOnly:d(),variants:[]};p(h);let g=f()?f()():{};t(`__pvtStory`,h),t(`__pvtAddVariant`,e=>{h.variants.push(e)}),n.init();var _=n.comment(),v=n.first_child(_);n.slot(v,i,`default`,{get state(){return g}},null),n.append(r,_),n.pop()}export{r as default};
+import{getContext as e,setContext as t}from"svelte";import"svelte/internal/disclose-version";import"svelte/internal/flags/legacy";import*as n from"svelte/internal/client";function r(r,i){n.push(i,!1);let a=n.prop(i,`title`,8,null),o=n.prop(i,`id`,8,null),s=n.prop(i,`group`,8,null),c=n.prop(i,`layout`,8,null),l=n.prop(i,`icon`,8,null),u=n.prop(i,`iconColor`,8,null),d=n.prop(i,`docsOnly`,8,!1),f=n.prop(i,`autoPropsDisabled`,8,null),p=n.prop(i,`initState`,8,null),m=e(`__pvtAddStory`),h=e(`__pvtStoryFile`),g={id:o()??h.id,title:a()??h.fileName,group:s(),layout:c(),icon:l(),iconColor:u(),docsOnly:d(),autoPropsDisabled:f(),variants:[]};m(g);let _=p()?p()():{};t(`__pvtStory`,g),t(`__pvtAddVariant`,e=>{g.variants.push(e)}),n.init();var v=n.comment(),y=n.first_child(v);n.slot(y,i,`default`,{get state(){return _}},null),n.append(r,v),n.pop()}export{r as default};

package/dist/collect/Story.svelte

@@ -8,6 +8,7 @@
   export let icon = null
   export let iconColor = null
   export let docsOnly = false
+  export let autoPropsDisabled = null
   export let initState = null
 
   const addStory = getContext('__pvtAddStory')
@@ -21,6 +22,10 @@
     icon,
     iconColor,
     docsOnly,
+    // Collected rather than inherited down: `MountStory` forwards story props
+    // only to an implicit variant (#466). Left undefined when unset, or the
+    // collector's `??=` merge could never apply `defaultStoryProps`.
+    autoPropsDisabled,
     variants: [],
   }
 

package/dist/index.node.js

@@ -3,13 +3,16 @@ import { createRequire } from 'node:module';
 import { dirname, join } from 'pathe';
 import { defaultColors } from 'poveste';
 import generateStoryCommand from './commands/generate-story.server.js';
+import { svelteAutoProps } from './util/auto-props-vite.js';
+import { svelteKitAssetsDir } from './util/kit-assets.js';
 import { listComponentFiles } from './util/list-components.js';
 import { disableStoryComponentHmr } from './util/story-hmr.js';
 export function HstSvelte() {
     return {
         name: '@poveste/plugin-svelte',
-        defaultConfig() {
+        async defaultConfig() {
             const svelteClientAliases = getSvelteClientAliases();
+            const publicDir = await svelteKitAssetsDir(process.cwd());
             return {
                 supportMatch: [
                     {
@@ -31,20 +34,14 @@ export function HstSvelte() {
                 viteIgnorePlugins: [
                     'vite-plugin-sveltekit-compile',
                 ],
-                vite: svelteClientAliases.length
-                    ? {
-                        plugins: [
-                            disableStoryComponentHmr(),
-                        ],
-                        resolve: {
-                            alias: svelteClientAliases,
-                        },
-                    }
-                    : {
-                        plugins: [
-                            disableStoryComponentHmr(),
-                        ],
-                    },
+                vite: {
+                    plugins: [
+                        svelteAutoProps(),
+                        disableStoryComponentHmr(),
+                    ],
+                    ...svelteClientAliases.length ? { resolve: { alias: svelteClientAliases } } : {},
+                    ...publicDir ? { publicDir } : {},
+                },
             };
         },
         supportPlugin: {

package/dist/util/auto-props-vite.d.ts

@@ -0,0 +1,9 @@
+/** Runs before `vite-plugin-svelte`: after it compiles there is nothing left to rewrite (#233). */
+export declare function svelteAutoProps(): {
+    name: string;
+    enforce: "pre";
+    transform(this: any, code: string, id: string): Promise<{
+        code: string;
+        map: any;
+    }>;
+};

package/dist/util/auto-props-vite.js

@@ -0,0 +1,38 @@
+import { readFile } from 'node:fs/promises';
+import { transformStoryAutoProps } from './auto-props.js';
+import { extractPropDefs } from './props.js';
+// Cheaper than a parse, and unlike a filename pattern it cannot go blind when a
+// project narrows `storyMatch`.
+const RENDERS_A_STORY = '<Hst.Story';
+const IMPORTS_A_COMPONENT = /from\s*['"][^'"]*\.svelte['"]/;
+/** Runs before `vite-plugin-svelte`: after it compiles there is nothing left to rewrite (#233). */
+export function svelteAutoProps() {
+    return {
+        name: 'poveste:svelte-auto-props',
+        enforce: 'pre',
+        async transform(code, id) {
+            if (!id.split('?')[0].endsWith('.svelte') || !code.includes(RENDERS_A_STORY) || !IMPORTS_A_COMPONENT.test(code)) {
+                return undefined;
+            }
+            const result = await transformStoryAutoProps(code, async (specifier) => {
+                const resolved = await this.resolve(specifier, id);
+                if (!resolved) {
+                    return undefined;
+                }
+                const file = resolved.id.split('?')[0];
+                // Baked into this module, so Vite has to know it depends on the source.
+                this.addWatchFile(file);
+                try {
+                    return extractPropDefs(await readFile(file, 'utf8'));
+                }
+                catch (error) {
+                    // Not a failed build, but silence would look like a component that
+                    // declares nothing.
+                    this.warn(`[poveste] could not read props from ${file}: ${error.message}`);
+                    return undefined;
+                }
+            });
+            return result === undefined ? undefined : { code: result, map: null };
+        },
+    };
+}

package/dist/util/auto-props.d.ts

@@ -0,0 +1,9 @@
+import type { PropDefinition } from '@poveste/shared';
+/** Resolves an import specifier from the story file to that component's props. */
+export type PropsOf = (specifier: string) => Promise<PropDefinition[] | undefined>;
+export declare function parseable(code: string): string;
+/**
+ * Every component a variant renders takes a spread of the values its controls
+ * hold; the props on offer come from the component's own source (#233).
+ */
+export declare function transformStoryAutoProps(code: string, propsOf: PropsOf): Promise<string | undefined>;

package/dist/util/auto-props.js

@@ -0,0 +1,230 @@
+import { parse } from 'svelte/compiler';
+const RUNTIME = '@poveste/plugin-svelte/auto-props';
+const HOLDER = '__pvtAutoProps';
+const TABLE = '__pvtAutoPropDefs';
+const HST = 'Hst';
+// Line-anchored and newline-free, or a match runs past its own line and blanks
+// the import below it. A trailing line comment is tolerated for the same reason.
+const TYPE_IMPORT = /^[ \t]*import\s+type\b[^;\n]+?\bfrom[ \t]*(['"])[^'"\n]*\1(?:[ \t]*;)?[ \t]*(?:\/\/[^\n]*)?$/gm;
+const IMPORT_BRACES = /\bimport\s*\{[^}]*\}/g;
+const INLINE_TYPE = /\btype\s+[A-Za-z_$][\w$]*(?:\s+as\s+[A-Za-z_$][\w$]*)?\s*,?/g;
+// Blanked rather than removed, so every offset still points at the same
+// character. `import type { Hst }` beside `export let Hst: Hst` reads as a
+// duplicate declaration.
+export function parseable(code) {
+    return code
+        .replace(TYPE_IMPORT, blank)
+        .replace(IMPORT_BRACES, braces => braces.replace(INLINE_TYPE, blank));
+}
+function blank(match) {
+    return ' '.repeat(match.length);
+}
+/**
+ * Every component a variant renders takes a spread of the values its controls
+ * hold; the props on offer come from the component's own source (#233).
+ */
+export async function transformStoryAutoProps(code, propsOf) {
+    // Applied twice, the second preamble redeclares the first.
+    if (code.includes(RUNTIME)) {
+        return undefined;
+    }
+    let ast;
+    try {
+        ast = parse(parseable(code), { modern: true });
+    }
+    catch {
+        return undefined;
+    }
+    const instance = ast.instance;
+    if (!instance) {
+        return undefined;
+    }
+    const imported = importedComponents(instance.content?.body ?? []);
+    if (imported.size === 0) {
+        return undefined;
+    }
+    const targets = collectTargets(ast.fragment, imported);
+    if (targets === undefined || targets.length === 0) {
+        return undefined;
+    }
+    const defs = await describe(targets, propsOf);
+    if (defs.every(perVariant => perVariant.length === 0)) {
+        return undefined;
+    }
+    return splice(code, instance.content.start, targets, defs);
+}
+// The only shape a component can arrive in.
+function importedComponents(body) {
+    const found = new Map();
+    for (const node of body) {
+        if (node.type !== 'ImportDeclaration' || !/\.svelte$/.test(node.source?.value ?? '')) {
+            continue;
+        }
+        for (const specifier of node.specifiers ?? []) {
+            if (specifier.type === 'ImportDefaultSpecifier') {
+                found.set(specifier.local.name, node.source.value);
+            }
+        }
+    }
+    return found;
+}
+/**
+ * Numbered within its variant, which is how `_hPropState` is keyed. Undefined
+ * means "do not touch this story": a variant a block produces is registered in
+ * an order no static pass can predict.
+ */
+function collectTargets(fragment, imported) {
+    const story = findStory(fragment);
+    if (!story || blockWrapsAVariant(story.fragment)) {
+        return undefined;
+    }
+    // At any depth and in document order, matching how `collect/Variant.svelte`
+    // registers them. A story with none renders its children as variant zero.
+    const variants = [];
+    walk(story.fragment, (node) => {
+        if (isHst(node, 'Variant')) {
+            variants.push(node);
+        }
+    });
+    const scopes = variants.length > 0 ? variants : [story];
+    const targets = [];
+    scopes.forEach((scope, variant) => {
+        let index = 0;
+        walk(scope.fragment, (node, ancestors) => {
+            // The controls snippet builds the panel, not the preview. A component in
+            // a block is skipped on its own.
+            if (isControls(node)) {
+                return false;
+            }
+            if (node.type !== 'Component' || insideBlock(ancestors)) {
+                return undefined;
+            }
+            const specifier = imported.get(node.name);
+            if (specifier) {
+                targets.push({ node, variant, index: index++, specifier });
+            }
+            return undefined;
+        });
+    });
+    return targets;
+}
+function findStory(fragment) {
+    let found;
+    walk(fragment, (node) => {
+        if (!found && isHst(node, 'Story')) {
+            found = node;
+        }
+    });
+    return found;
+}
+function blockWrapsAVariant(fragment) {
+    let wrapped = false;
+    walk(fragment, (node, ancestors) => {
+        if (isHst(node, 'Variant') && insideBlock(ancestors)) {
+            wrapped = true;
+        }
+    });
+    return wrapped;
+}
+function insideBlock(ancestors) {
+    return ancestors.some(ancestor => ancestor.type.endsWith('Block') && ancestor.type !== 'SnippetBlock');
+}
+function isControls(node) {
+    if (node.type === 'SnippetBlock') {
+        return node.expression?.name === 'controls';
+    }
+    return (node.attributes ?? []).some((attribute) => attribute.name === 'slot' && attribute.value?.[0]?.data === 'controls');
+}
+function isHst(node, member) {
+    return node.type === 'Component' && (member ? node.name === `${HST}.${member}` : node.name?.startsWith(`${HST}.`));
+}
+// `then`/`catch`/`pending` and `fallback` are branches a variant can hide in.
+const CHILD_KEYS = ['fragment', 'nodes', 'children', 'body', 'consequent', 'alternate', 'pending', 'then', 'catch', 'fallback'];
+function walk(node, visit, ancestors = []) {
+    if (!node || typeof node !== 'object') {
+        return;
+    }
+    if (Array.isArray(node)) {
+        for (const child of node)
+            walk(child, visit, ancestors);
+        return;
+    }
+    if (typeof node.type === 'string') {
+        if (visit(node, ancestors) === false) {
+            return;
+        }
+        ancestors = [...ancestors, node];
+    }
+    for (const key of CHILD_KEYS) {
+        if (node[key])
+            walk(node[key], visit, ancestors);
+    }
+}
+async function describe(targets, propsOf) {
+    const sources = new Map();
+    for (const target of targets) {
+        if (!sources.has(target.specifier)) {
+            sources.set(target.specifier, propsOf(target.specifier));
+        }
+    }
+    const size = targets.reduce((max, target) => Math.max(max, target.variant + 1), 0);
+    const defs = Array.from({ length: size }, () => []);
+    for (const target of targets) {
+        const props = await sources.get(target.specifier);
+        if (props?.length) {
+            defs[target.variant].push({ name: target.node.name, index: target.index, props });
+        }
+    }
+    return defs;
+}
+/**
+ * Back to front, so an earlier insertion cannot move a later offset. The spread
+ * goes after the last attribute: last wins, so a prop the story binds keeps
+ * winning until the reader touches that control.
+ */
+function splice(code, scriptStart, targets, defs) {
+    const driven = new Set(defs.flatMap((perVariant, variant) => perVariant.map(def => `${variant}:${def.index}`)));
+    const edits = targets
+        .filter(target => driven.has(`${target.variant}:${target.index}`))
+        .map(target => ({
+        at: attributesEnd(code, target.node),
+        text: ` {...$${HOLDER}[${target.variant}][${target.index}]}`,
+    }));
+    // One line, at the end of the `<script>` line, so nothing the story wrote moves.
+    edits.push({ at: scriptStart, text: preamble(defs) });
+    let result = code;
+    for (const edit of edits.sort((a, b) => b.at - a.at)) {
+        result = result.slice(0, edit.at) + edit.text + result.slice(edit.at);
+    }
+    return result;
+}
+// Serialised once and referenced, or a hundred-variant story carries a hundred
+// copies of the same prop table.
+function preamble(defs) {
+    const table = [];
+    const entries = defs.map(perVariant => perVariant.map((def) => {
+        const serialised = literal({ name: def.name, props: def.props });
+        let slot = table.indexOf(serialised);
+        if (slot < 0) {
+            slot = table.push(serialised) - 1;
+        }
+        return `{...${TABLE}[${slot}],index:${def.index}}`;
+    }));
+    return `import { autoProps as __pvtCreateAutoProps } from '${RUNTIME}';`
+        + `const ${TABLE} = [${table.join(',')}];`
+        + `const ${HOLDER} = __pvtCreateAutoProps([${entries.map(perVariant => `[${perVariant.join(',')}]`).join(',')}]);`;
+}
+// `</script>` in a default would close the block this lands in.
+function literal(value) {
+    return JSON.stringify(value)
+        .replace(/</g, '\\u003C')
+        .replace(/\u2028/g, '\\u2028')
+        .replace(/\u2029/g, '\\u2029');
+}
+function attributesEnd(code, node) {
+    const attributes = node.attributes ?? [];
+    if (attributes.length > 0) {
+        return Math.max(...attributes.map((attribute) => attribute.end));
+    }
+    return code.indexOf(node.name, node.start) + node.name.length;
+}

package/dist/util/init-state-warning.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Whether to warn that a variant has controls but no `initState`.
+ *
+ * The warning is real — a controls snippet with no seeded state renders controls
+ * whose edits cannot reach the story, because the story is mounted separately per
+ * slot. But it fired on stories where the state *is* seeded, from `initState` on
+ * the `Story` rather than the `Variant`, and told their authors that working
+ * controls were broken (#462).
+ *
+ * `seeded` is the signal it was missing: `RenderStory` sets `__pvtStateSeeded`
+ * when it applies a story-level `initState`, on the same object this already
+ * holds. Only the variant-level check was wrong; the story-level one is correct.
+ */
+export declare function shouldWarnAboutMissingInitState(options: {
+    hasInitState: boolean;
+    seeded: boolean;
+    slotName: string;
+    hasControlsSlot: boolean;
+    alreadyWarned: boolean;
+}): boolean;

package/dist/util/init-state-warning.js

@@ -0,0 +1,22 @@
+/**
+ * Whether to warn that a variant has controls but no `initState`.
+ *
+ * The warning is real — a controls snippet with no seeded state renders controls
+ * whose edits cannot reach the story, because the story is mounted separately per
+ * slot. But it fired on stories where the state *is* seeded, from `initState` on
+ * the `Story` rather than the `Variant`, and told their authors that working
+ * controls were broken (#462).
+ *
+ * `seeded` is the signal it was missing: `RenderStory` sets `__pvtStateSeeded`
+ * when it applies a story-level `initState`, on the same object this already
+ * holds. Only the variant-level check was wrong; the story-level one is correct.
+ */
+export function shouldWarnAboutMissingInitState(options) {
+    const { hasInitState, seeded, slotName, hasControlsSlot, alreadyWarned } = options;
+    if (hasInitState || seeded || alreadyWarned) {
+        return false;
+    }
+    // Controls mount only: the two mounts do not share a realm for iframe layouts,
+    // so this is what keeps it to one warning.
+    return slotName === 'controls' && hasControlsSlot;
+}

package/dist/util/kit-assets.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Where a SvelteKit project keeps its static assets, or undefined when this is
+ * not one.
+ *
+ * `vite-plugin-sveltekit-compile` is what sets Vite's `publicDir` to
+ * `kit.files.assets`, and poveste drops that plugin through `viteIgnorePlugins`
+ * — so a book served none of a Kit project's `static/`, in dev or in the build
+ * (#463). This restores the one value that went with it.
+ */
+export declare function svelteKitAssetsDir(cwd: string): Promise<string | undefined>;

package/dist/util/kit-assets.js

@@ -0,0 +1,51 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import { isAbsolute, join } from 'pathe';
+/**
+ * Where a SvelteKit project keeps its static assets, or undefined when this is
+ * not one.
+ *
+ * `vite-plugin-sveltekit-compile` is what sets Vite's `publicDir` to
+ * `kit.files.assets`, and poveste drops that plugin through `viteIgnorePlugins`
+ * — so a book served none of a Kit project's `static/`, in dev or in the build
+ * (#463). This restores the one value that went with it.
+ */
+export async function svelteKitAssetsDir(cwd) {
+    if (!declaresKit(cwd)) {
+        return undefined;
+    }
+    const assets = await configuredAssetsDir(cwd) ?? 'static';
+    return isAbsolute(assets) ? assets : join(cwd, assets);
+}
+// The project's own manifest, not `require.resolve`: resolution walks up out of
+// the project and finds Kit through a sibling in a workspace store, which
+// reported a plain Svelte book as SvelteKit and pointed its `publicDir` at a
+// `static/` that does not exist — losing the `public/` it actually had.
+function declaresKit(cwd) {
+    try {
+        const manifest = JSON.parse(readFileSync(join(cwd, 'package.json'), 'utf8'));
+        return ['dependencies', 'devDependencies', 'peerDependencies']
+            .some(field => manifest[field]?.['@sveltejs/kit']);
+    }
+    catch {
+        return false;
+    }
+}
+// Kit reads this from `svelte.config.js` and defaults it to `static`. Reading it
+// rather than assuming the default is what makes a project that moved its assets
+// work; a config that will not load is not this plugin's failure to report, so
+// the default stands in.
+async function configuredAssetsDir(cwd) {
+    const configPath = join(cwd, 'svelte.config.js');
+    if (!existsSync(configPath)) {
+        return undefined;
+    }
+    try {
+        const loaded = await import(pathToFileURL(configPath).href);
+        const assets = loaded.default?.kit?.files?.assets;
+        return typeof assets === 'string' ? assets : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/util/props.d.ts

@@ -0,0 +1,3 @@
+import type { PropDefinition } from '@poveste/shared';
+/** The props declared, or `undefined` when the source could not be read. */
+export declare function extractPropDefs(source: string): PropDefinition[] | undefined;

package/dist/util/props.js

@@ -0,0 +1,279 @@
+// A compiled Svelte component keeps no record of what it accepts, the way a Vue
+// vnode does, so the source is the only place its props still exist (#233).
+import { parse } from 'svelte/compiler';
+// Poveste injects this into every story file; no user sets it.
+const INJECTED = 'Hst';
+const SCRIPT_BLOCK = /<script[^>]*>[\s\S]*?<\/script>/gi;
+// Line-anchored: a mention in a comment must not start a match.
+const TYPE_IMPORT = /^[ \t]*import\s+type\b[^;]+?\bfrom[ \t]*(['"])[^'"]*\1(?:[ \t]*;)?[ \t]*$/gm;
+const IMPORT_BRACES = /\bimport\s*\{([^}]*)\}/g;
+// Script blocks only: props live nowhere else, and a preprocessed `<style>`
+// never reaches the parser to throw. Type-only imports still go, both spellings
+// — `import type { Hst }` beside `export let Hst: Hst` reads as a redeclaration.
+function parseable(source) {
+    return (source.match(SCRIPT_BLOCK) ?? [])
+        .join('\n')
+        .replace(TYPE_IMPORT, '')
+        .replace(IMPORT_BRACES, (_, specifiers) => {
+        const kept = specifiers.split(',').map(s => s.trim()).filter(s => s && !/^type\s/.test(s));
+        return `import { ${kept.join(', ')} }`;
+    });
+}
+function nameOf(typeName) {
+    return typeName?.name ?? typeName?.right?.name;
+}
+function withoutNullish(types) {
+    return types.filter((m) => m.type !== 'TSUndefinedKeyword' && m.type !== 'TSNullKeyword');
+}
+// Slot content, which no control can author. Function props are kept — Vue's
+// auto-props lists them too.
+function isSnippet(node) {
+    if (!node) {
+        return false;
+    }
+    if (node.type === 'TSParenthesizedType') {
+        return isSnippet(node.typeAnnotation);
+    }
+    if (node.type === 'TSUnionType') {
+        const real = withoutNullish(node.types);
+        return real.length > 0 && real.every((m) => isSnippet(m));
+    }
+    return nameOf(node.typeName) === 'Snippet';
+}
+// Only `undefined` makes a prop omittable; `string | null` still has to be passed.
+function acceptsUndefined(node) {
+    if (node?.type === 'TSParenthesizedType') {
+        return acceptsUndefined(node.typeAnnotation);
+    }
+    return node?.type === 'TSUnionType'
+        && node.types.some((m) => m.type === 'TSUndefinedKeyword');
+}
+function typesFromAnnotation(node) {
+    if (!node) {
+        return undefined;
+    }
+    switch (node.type) {
+        case 'TSStringKeyword': return ['string'];
+        case 'TSNumberKeyword': return ['number'];
+        case 'TSBooleanKeyword': return ['boolean'];
+        case 'TSArrayType':
+        case 'TSTupleType': return ['array'];
+        case 'TSTypeOperator':
+        case 'TSParenthesizedType': return typesFromAnnotation(node.typeAnnotation);
+        case 'TSTypeLiteral': return ['object'];
+        case 'TSLiteralType': return [typeName(literalValue(node.literal))];
+        case 'TSUnionType': return unionTypes(node);
+        case 'TSTypeReference':
+            return ['Array', 'ReadonlyArray'].includes(nameOf(node.typeName) ?? '') ? ['array'] : ['unknown'];
+        default: return ['unknown'];
+    }
+}
+function typeName(value) {
+    switch (typeof value) {
+        case 'string': return 'string';
+        case 'number': return 'number';
+        case 'boolean': return 'boolean';
+        default: return 'unknown';
+    }
+}
+// `unknown` sorts last because the panel reads `types[0]`, so a concrete type
+// wins however the union was written.
+function unionTypes(node) {
+    const members = withoutNullish(node.types)
+        .flatMap((m) => typesFromAnnotation(m) ?? []);
+    return [...new Set(members)].sort((a, b) => Number(a === 'unknown') - Number(b === 'unknown'));
+}
+function typesFromValue(value) {
+    const name = typeName(value);
+    return name === 'unknown' ? undefined : [name];
+}
+// The only place a definition is built, so the filters cannot be bypassed.
+function propDef(name, annotation, init, optional) {
+    if (name === INJECTED || isSnippet(annotation)) {
+        return undefined;
+    }
+    const value = literalValue(init);
+    return {
+        name,
+        types: typesFromAnnotation(annotation) ?? typesFromValue(value),
+        required: !optional && init == null && !acceptsUndefined(annotation),
+        default: value,
+    };
+}
+function localBindings(body) {
+    const found = new Map();
+    for (const node of body) {
+        const declaration = node.type === 'ExportNamedDeclaration' ? node.declaration : node;
+        if (declaration?.type === 'VariableDeclaration') {
+            for (const declarator of declaration.declarations) {
+                if (declarator.id.type === 'Identifier') {
+                    found.set(declarator.id.name, {
+                        kind: declaration.kind,
+                        annotation: declarator.id.typeAnnotation?.typeAnnotation,
+                        init: declarator.init,
+                    });
+                }
+            }
+        }
+        if (declaration?.type === 'FunctionDeclaration' && declaration.id) {
+            found.set(declaration.id.name, { kind: 'function' });
+        }
+    }
+    return found;
+}
+// `export let x` is a prop, and `export { x as y }` when `x` is a `let`. An
+// accessor, a re-export and a type-only export are not.
+function legacyProps(body) {
+    const props = [];
+    const locals = localBindings(body);
+    for (const node of body) {
+        if (node.type !== 'ExportNamedDeclaration' || node.exportKind === 'type' || node.source) {
+            continue;
+        }
+        if (!node.declaration && node.specifiers?.length) {
+            for (const specifier of node.specifiers) {
+                const local = locals.get(specifier.local?.name);
+                const def = local?.kind === 'let'
+                    ? propDef(specifier.exported?.name, local.annotation, local.init, false)
+                    : undefined;
+                if (def) {
+                    props.push(def);
+                }
+            }
+            continue;
+        }
+        if (node.declaration?.type !== 'VariableDeclaration' || node.declaration.kind !== 'let') {
+            continue;
+        }
+        for (const declarator of node.declaration.declarations) {
+            if (declarator.id.type !== 'Identifier') {
+                continue;
+            }
+            const def = propDef(declarator.id.name, declarator.id.typeAnnotation?.typeAnnotation, declarator.init, false);
+            if (def) {
+                props.push(def);
+            }
+        }
+    }
+    return props;
+}
+function runesProps(body, declared) {
+    const declarator = body
+        .filter((node) => node.type === 'VariableDeclaration')
+        .flatMap((node) => node.declarations)
+        .find((d) => d.init?.type === 'CallExpression' && d.init.callee?.name === '$props');
+    return declarator ? fromDeclarator(declarator, declared) : [];
+}
+function declaredTypes(body) {
+    const found = new Map();
+    for (const node of body) {
+        const declaration = node.type === 'ExportNamedDeclaration' ? node.declaration : node;
+        if (declaration?.type === 'TSInterfaceDeclaration') {
+            found.set(declaration.id.name, { type: 'TSTypeLiteral', members: declaration.body.body });
+        }
+        if (declaration?.type === 'TSTypeAliasDeclaration') {
+            found.set(declaration.id.name, declaration.typeAnnotation);
+        }
+    }
+    return found;
+}
+// An alias may intersect literals and other declared names.
+function membersOf(node, declared, depth = 0) {
+    if (!node || depth > 4) {
+        return undefined;
+    }
+    if (node.type === 'TSTypeLiteral') {
+        return node.members;
+    }
+    if (node.type === 'TSTypeReference') {
+        return membersOf(declared.get(nameOf(node.typeName) ?? ''), declared, depth + 1);
+    }
+    if (node.type === 'TSIntersectionType') {
+        const parts = node.types.flatMap((t) => membersOf(t, declared, depth + 1) ?? []);
+        return parts.length > 0 ? parts : undefined;
+    }
+    return undefined;
+}
+// The annotation and the destructuring each know something the other does not:
+// the annotation carries types and optionality, the destructuring carries
+// defaults and every prop an `extends` clause hides. Merge rather than choose.
+function fromDeclarator(declarator, declared) {
+    const destructured = destructuredDefaults(declarator.id);
+    const members = membersOf(declarator.id.typeAnnotation?.typeAnnotation, declared);
+    const defs = [];
+    const seen = new Set();
+    for (const member of members ?? []) {
+        if (member.key?.type !== 'Identifier') {
+            continue;
+        }
+        // Seen before the kind check, so a method signature is not re-added below.
+        seen.add(member.key.name);
+        if (member.type !== 'TSPropertySignature') {
+            continue;
+        }
+        const def = propDef(member.key.name, member.typeAnnotation?.typeAnnotation, destructured.get(member.key.name), member.optional);
+        if (def) {
+            defs.push(def);
+        }
+    }
+    for (const [name, init] of destructured) {
+        // `children` is the default snippet in runes mode; with no annotation to
+        // read, the name is the only thing that says so.
+        if (seen.has(name) || name === 'children') {
+            continue;
+        }
+        // Unannotated, the destructuring is the only signal; annotated, an
+        // inherited prop's optionality is unknowable.
+        const def = propDef(name, undefined, init, members !== undefined);
+        if (def) {
+            defs.push(def);
+        }
+    }
+    return defs;
+}
+function destructuredDefaults(id) {
+    const found = new Map();
+    if (id.type !== 'ObjectPattern') {
+        return found;
+    }
+    for (const property of id.properties) {
+        if (property.type !== 'Property' || property.computed || property.key.type !== 'Identifier') {
+            continue;
+        }
+        found.set(property.key.name, property.value.type === 'AssignmentPattern' ? property.value.right : undefined);
+    }
+    return found;
+}
+// Only what a control can hold and JSON can carry. A `$bindable` default is one
+// node deeper.
+function literalValue(node) {
+    if (!node) {
+        return undefined;
+    }
+    if (node.type === 'CallExpression' && node.callee?.name === '$bindable') {
+        return literalValue(node.arguments?.[0]);
+    }
+    if (node.type === 'UnaryExpression' && node.operator === '-') {
+        const inner = literalValue(node.argument);
+        return typeof inner === 'number' ? -inner : undefined;
+    }
+    if (node.type !== 'Literal') {
+        return undefined;
+    }
+    return typeof node.value === 'bigint' || node.value instanceof RegExp ? undefined : node.value;
+}
+/** The props declared, or `undefined` when the source could not be read. */
+export function extractPropDefs(source) {
+    let ast;
+    try {
+        ast = parse(parseable(source), { modern: true });
+    }
+    catch {
+        return undefined;
+    }
+    // Types may be declared in the module script; props never are.
+    const body = ast.instance?.content?.body ?? [];
+    const declared = declaredTypes([...(ast.module?.content?.body ?? []), ...body]);
+    const runes = runesProps(body, declared);
+    return runes.length > 0 ? runes : legacyProps(body);
+}

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@poveste/plugin-svelte",
   "type": "module",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Poveste plugin for Svelte 5 and SvelteKit support",
   "author": {
-    "name": "Sorin Gitlan"
+    "name": "Sorin Gitlan",
+    "url": "https://x.com/50rayn"
   },
   "license": "MIT",
   "homepage": "https://poveste.dev",
@@ -41,6 +42,10 @@
       "types": "./dist/collect/index.d.ts",
       "default": "./dist/collect/index.js"
     },
+    "./auto-props": {
+      "types": "./dist/client/auto-props.d.ts",
+      "default": "./dist/client/auto-props.js"
+    },
     ".": "./dist/index.node.js",
     "./*": "./*"
   },
@@ -49,6 +54,7 @@
   "types": "./dist/index.node.d.ts",
   "files": [
     "assets",
+    "auto-props.d.ts",
     "client.d.ts",
     "collect.d.ts",
     "dist"
@@ -59,8 +65,8 @@
   "peerDependencies": {
     "@sveltejs/kit": "^2.53.0",
     "@sveltejs/vite-plugin-svelte": "^7.0.0",
-    "svelte": "^5.46.4",
-    "poveste": "^0.10.0"
+    "poveste": "^0.12.0",
+    "svelte": "^5.46.4"
   },
   "peerDependenciesMeta": {
     "@sveltejs/kit": {
@@ -68,13 +74,13 @@
     }
   },
   "dependencies": {
+    "@poveste/controls": "^0.12.0",
+    "@poveste/shared": "^0.12.0",
+    "@poveste/vendors": "^0.12.0",
     "change-case": "^5.4.4",
     "globby": "^14.0.2",
     "launch-editor": "^2.9.1",
-    "pathe": "^1.1.2",
-    "@poveste/controls": "^0.10.0",
-    "@poveste/shared": "^0.10.0",
-    "@poveste/vendors": "^0.10.0"
+    "pathe": "^1.1.2"
   },
   "devDependencies": {
     "@sveltejs/vite-plugin-svelte": "^7.0.0",
@@ -82,15 +88,18 @@
     "concurrently": "^9.1.0",
     "fs-extra": "^11.2.0",
     "globby": "^14.0.2",
+    "poveste": "0.12.0",
     "svelte": "5.55.0",
     "svelte-preprocess": "^6.0.3",
     "typescript": "5.6.3",
     "vite": "^8.0.0",
-    "poveste": "0.10.0"
+    "vitest": "^4.1.10"
   },
   "scripts": {
     "build": "rimraf dist && vite build && tsc -d -P tsconfig.build.json && pnpm run build:types",
     "build:types": "tsc --declaration --emitDeclarationOnly",
+    "test": "vitest run",
+    "test:dev": "vitest",
     "watch": "concurrently \"vite build --watch\" \"tsc -d -P tsconfig.build.json --watch\" \"pnpm run build:types --watch\""
   }
 }