@roblawn/devtool-runtime 0.1.0-alpha.0 → 0.1.0-alpha.1

package/LICENSE.md

@@ -1,11 +1,11 @@
-Proprietary Alpha License
-
-Copyright (c) 2026 Rob Lawn. All rights reserved.
-
-Permission is granted to install and use this package as a runtime dependency of generated visual site authoring projects.
-
-This package is proprietary. No ownership or copyright interest is transferred. You may not redistribute, resell, sublicense, or repackage this package as a competing runtime, framework, scaffold, starter, or component product without prior written permission.
-
-This software is provided "as is", without warranty of any kind, express or implied, including but not limited to warranties of merchantability, fitness for a particular purpose, non-infringement, availability, security, or correctness. Use is at your own risk.
-
-In no event shall the copyright holder or contributors be liable for any claim, damages, data loss, business interruption, or other liability arising from use of this software.
+Proprietary Alpha License
+
+Copyright (c) 2026 Rob Lawn. All rights reserved.
+
+Permission is granted to install and use this package as a runtime dependency of generated visual site authoring projects.
+
+This package is proprietary. No ownership or copyright interest is transferred. You may not redistribute, resell, sublicense, or repackage this package as a competing runtime, framework, scaffold, starter, or component product without prior written permission.
+
+This software is provided "as is", without warranty of any kind, express or implied, including but not limited to warranties of merchantability, fitness for a particular purpose, non-infringement, availability, security, or correctness. Use is at your own risk.
+
+In no event shall the copyright holder or contributors be liable for any claim, damages, data loss, business interruption, or other liability arising from use of this software.

package/README.md

@@ -1,7 +1,7 @@
-# @roblawn/devtool-runtime
-
-Alpha runtime primitives for generated visual site authoring projects.
-
-This package is intended to be installed by a compatible starter creator and consumed by generated sites.
-
-This package is proprietary alpha software, supplied as-is. See `LICENSE.md`.
+# @roblawn/devtool-runtime
+
+Alpha runtime primitives for generated visual site authoring projects.
+
+This package is intended to be installed by a compatible starter creator and consumed by generated sites.
+
+This package is proprietary alpha software, supplied as-is. See `LICENSE.md`.

package/dist/content/envelope.d.ts

@@ -0,0 +1,54 @@
+import type { ContentProviderName, ContentTarget } from './targets.js';
+export declare const CONTENT_CONTRACT_VERSION: "published-content.v1";
+export type ContentContractVersion = typeof CONTENT_CONTRACT_VERSION;
+export type ContentBag = Record<string, unknown>;
+export interface ContentEnvelope {
+    contractVersion: ContentContractVersion;
+    target: ContentTarget;
+    scope: string;
+    content: ContentBag;
+    items?: SlotItem[];
+    meta?: ContentEnvelopeMeta;
+}
+export interface ContentEnvelopeMeta {
+    templateDir?: string;
+    provider?: ContentProviderName;
+    providerId?: string;
+    etag?: string;
+    [key: string]: unknown;
+}
+export type LoadState = 'idle' | 'loading' | 'ready' | 'error';
+export type SlotItem = BlockSlotItem | ModuleSlotItem | CustomSlotItem;
+export interface BlockSlotItem {
+    kind: 'block';
+    key?: string;
+    type: string;
+    props?: Record<string, unknown>;
+    layout?: Record<string, unknown>;
+    scope?: string;
+    providerId?: string;
+    providerKey?: string;
+}
+export interface ModuleSlotItem {
+    kind: 'module';
+    key?: string;
+    type?: string;
+    subType: string;
+    slug: string;
+    instance?: string;
+    instanceId?: string;
+    scope: string;
+    providerId?: string;
+    providerKey?: string;
+}
+export interface CustomSlotItem {
+    key: string;
+    kind?: string;
+    type: string;
+    props?: Record<string, unknown>;
+    scope?: string;
+    instance?: string;
+    providerId?: string;
+    providerKey?: string;
+}
+export declare function createContentEnvelope(input: Omit<ContentEnvelope, 'contractVersion'>): ContentEnvelope;

package/dist/content/envelope.js

@@ -0,0 +1,10 @@
+export const CONTENT_CONTRACT_VERSION = 'published-content.v1';
+export function createContentEnvelope(input) {
+    return {
+        contractVersion: CONTENT_CONTRACT_VERSION,
+        ...input,
+        content: { ...input.content },
+        items: input.items ? input.items.map((item) => ({ ...item })) : undefined,
+        meta: input.meta ? { ...input.meta } : undefined,
+    };
+}

package/dist/content/envelopeResolver.d.ts

@@ -0,0 +1,14 @@
+import { type ContentEnvelope } from './envelope.js';
+import type { ContentTarget } from './targets.js';
+export type ContentStash = Record<string, ContentEnvelope>;
+type ContentGlobal = {
+    window?: Record<string, ContentStash | undefined>;
+};
+export declare function contentTargetKey(target: ContentTarget): string;
+export declare function getContentStash(root?: ContentGlobal, stashKey?: string): ContentStash;
+export declare function setContentStashEntry(key: string, envelope: ContentEnvelope, root?: ContentGlobal, stashKey?: string): void;
+export declare function templateDirForSlug(slug: string): string;
+export declare function fallbackScope(target: ContentTarget): string;
+export declare function coerceContentEnvelope(json: unknown, target: ContentTarget, scope?: string, meta?: Record<string, unknown>): ContentEnvelope;
+export declare function isContentTarget(value: unknown): value is ContentTarget;
+export {};

package/dist/content/envelopeResolver.js

@@ -0,0 +1,77 @@
+import { createContentEnvelope } from './envelope.js';
+import { createModuleScope, createPageScope } from './scope.js';
+export function contentTargetKey(target) {
+    if (target.kind === 'page')
+        return `page:${target.slug}`;
+    if (target.kind === 'global')
+        return `global:${target.slug}:${target.scope ?? ''}`;
+    return [
+        'module',
+        target.subType,
+        target.slug,
+        target.instance ?? '',
+        target.scope ?? '',
+        target.providerId ?? '',
+    ].join(':');
+}
+export function getContentStash(root = globalThis, stashKey = '__CONTENT_STASH__') {
+    return root.window?.[stashKey] ?? {};
+}
+export function setContentStashEntry(key, envelope, root = globalThis, stashKey = '__CONTENT_STASH__') {
+    if (!root.window)
+        return;
+    root.window[stashKey] = {
+        ...(root.window[stashKey] ?? {}),
+        [key]: envelope,
+    };
+}
+export function templateDirForSlug(slug) {
+    return slug
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+export function fallbackScope(target) {
+    if (target.kind === 'page')
+        return createPageScope(target.slug);
+    if (target.kind === 'module') {
+        return target.scope ?? createModuleScope(target.subType, target.slug, target.instance);
+    }
+    return target.scope ?? `global_${target.slug}`;
+}
+export function coerceContentEnvelope(json, target, scope = fallbackScope(target), meta = {}) {
+    if (isRecord(json) && isRecord(json.content)) {
+        return createContentEnvelope({
+            target: isContentTarget(json.target) ? json.target : target,
+            scope: typeof json.scope === 'string' ? json.scope : scope,
+            content: json.content,
+            items: Array.isArray(json.items) ? json.items : [],
+            meta: {
+                ...meta,
+                ...(isRecord(json.meta) ? json.meta : {}),
+                ...(typeof json.contractVersion === 'string' ? { contractVersion: json.contractVersion } : {}),
+                ...(Array.isArray(json.entries) ? { entries: json.entries } : {}),
+            },
+        });
+    }
+    return createContentEnvelope({
+        target,
+        scope,
+        content: isRecord(json) ? json : {},
+        items: [],
+        meta,
+    });
+}
+export function isContentTarget(value) {
+    if (!isRecord(value) || typeof value.kind !== 'string')
+        return false;
+    if (value.kind === 'page')
+        return typeof value.slug === 'string';
+    if (value.kind === 'global')
+        return typeof value.slug === 'string';
+    return value.kind === 'module' && typeof value.subType === 'string' && typeof value.slug === 'string';
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/content/identity.d.ts

@@ -0,0 +1,16 @@
+export type ContentKey = string;
+export type SlotKey = string;
+export type ContentScope = string;
+export type ProviderId = string;
+export type ProviderKey = string;
+export type AuthoringStableId = string;
+export interface ProviderIdentity {
+    providerId?: ProviderId;
+    providerKey?: ProviderKey;
+}
+export interface ContentIdentity extends ProviderIdentity {
+    contentKey: ContentKey;
+    scope?: ContentScope;
+    instance?: string;
+    stableId?: AuthoringStableId;
+}

package/dist/content/identity.js

@@ -0,0 +1 @@
+export {};

package/dist/content/index.d.ts

@@ -0,0 +1,10 @@
+export * from './targets.js';
+export * from './envelope.js';
+export * from './identity.js';
+export * from './scope.js';
+export * from './provider.js';
+export * from './normalize.js';
+export * from './profile.js';
+export * from './safeContent.js';
+export * from './slotItems.js';
+export * from './envelopeResolver.js';

package/dist/content/index.js

@@ -0,0 +1,10 @@
+export * from './targets.js';
+export * from './envelope.js';
+export * from './identity.js';
+export * from './scope.js';
+export * from './provider.js';
+export * from './normalize.js';
+export * from './profile.js';
+export * from './safeContent.js';
+export * from './slotItems.js';
+export * from './envelopeResolver.js';

package/dist/content/normalize.d.ts

@@ -0,0 +1,8 @@
+import { type ContentEnvelope } from './envelope.js';
+import type { ContentTarget } from './targets.js';
+export interface NormalizeContentEnvelopeOptions {
+    target: ContentTarget;
+    scope: string;
+}
+export declare function normalizeContentEnvelope(value: unknown, options: NormalizeContentEnvelopeOptions): ContentEnvelope;
+export declare function isContentEnvelope(value: unknown): value is ContentEnvelope;

package/dist/content/normalize.js

@@ -0,0 +1,53 @@
+import { CONTENT_CONTRACT_VERSION } from './envelope.js';
+const LEGACY_CONTENT_CONTRACT_VERSION = ['tun', 'dra.published-content.v1'].join('');
+export function normalizeContentEnvelope(value, options) {
+    if (isContentEnvelope(value)) {
+        return {
+            contractVersion: CONTENT_CONTRACT_VERSION,
+            target: value.target,
+            scope: value.scope,
+            content: cloneRecord(value.content),
+            items: Array.isArray(value.items) ? value.items.map(cloneSlotItem) : undefined,
+            meta: isRecord(value.meta) ? cloneRecord(value.meta) : undefined,
+        };
+    }
+    if (isRecord(value)) {
+        return {
+            contractVersion: CONTENT_CONTRACT_VERSION,
+            target: options.target,
+            scope: options.scope,
+            content: cloneRecord(value),
+        };
+    }
+    throw new Error('Content envelope must be an object.');
+}
+export function isContentEnvelope(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.contractVersion !== CONTENT_CONTRACT_VERSION &&
+        value.contractVersion !== LEGACY_CONTENT_CONTRACT_VERSION) {
+        return false;
+    }
+    if (!isRecord(value.target))
+        return false;
+    if (typeof value.scope !== 'string')
+        return false;
+    if (!isRecord(value.content))
+        return false;
+    return true;
+}
+function cloneRecord(value) {
+    return { ...value };
+}
+function cloneSlotItem(item) {
+    if ('props' in item) {
+        return {
+            ...item,
+            props: item.props ? { ...item.props } : undefined,
+        };
+    }
+    return { ...item };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/content/profile.d.ts

@@ -0,0 +1,11 @@
+export type ContentProfile = 'local' | 'embedded-json' | 'cms';
+export interface ResolveContentProfileOptions {
+    env?: Record<string, string | undefined>;
+    override?: string;
+    mode?: string;
+}
+export declare function resolveContentProfile(options?: ResolveContentProfileOptions): ContentProfile;
+export declare function isCmsProfile(profile: ContentProfile): boolean;
+export declare function localBasePrefix(profile: ContentProfile): string;
+export declare function localPageUrl(slug: string, profile: ContentProfile): string;
+export declare function localModuleUrls(subType: string, slug: string, profile: ContentProfile, instance?: string): string[];

package/dist/content/profile.js

@@ -0,0 +1,29 @@
+const LEGACY_NAME = ['TUN', 'DRA'].join('');
+const LOCAL_PRIVATE_BASE = `/.${LEGACY_NAME.toLowerCase()}`;
+const LOCAL_PUBLIC_BASE = `/__${LEGACY_NAME.toLowerCase()}`;
+export function resolveContentProfile(options = {}) {
+    const env = options.env ?? {};
+    const raw = options.override ??
+        env.VITE_DEVTOOL_CONTENT_PROFILE ??
+        env[`VITE_${LEGACY_NAME}_CONTENT_PROFILE`] ??
+        (options.mode === 'preview' || options.mode === 'ssg' ? 'embedded-json' : 'local');
+    if (raw === 'cms' || raw === 'embedded-json' || raw === 'local')
+        return raw;
+    return 'local';
+}
+export function isCmsProfile(profile) {
+    return profile === 'cms';
+}
+export function localBasePrefix(profile) {
+    return profile === 'embedded-json' ? LOCAL_PUBLIC_BASE : LOCAL_PRIVATE_BASE;
+}
+export function localPageUrl(slug, profile) {
+    const safe = slug.replace(/^\/+|\/+$/g, '');
+    return `${localBasePrefix(profile)}/pages/${encodeURIComponent(safe)}/content.json`;
+}
+export function localModuleUrls(subType, slug, profile, instance) {
+    const root = `${localBasePrefix(profile)}/modules/${encodeURIComponent(subType)}/${encodeURIComponent(slug)}`;
+    return instance
+        ? [`${root}/${encodeURIComponent(instance)}/content.json`, `${root}/content.json`]
+        : [`${root}/content.json`];
+}

package/dist/content/provider.d.ts

@@ -0,0 +1,17 @@
+import type { ContentEnvelope } from './envelope.js';
+import type { ContentProviderName, ContentTarget } from './targets.js';
+export interface ContentReadProvider {
+    name: ContentProviderName;
+    resolve(target: ContentTarget): Promise<ContentEnvelope>;
+}
+export interface ContentWriteProvider {
+    name: ContentProviderName;
+    write(envelope: ContentEnvelope): Promise<ContentWriteResult>;
+}
+export interface ContentWriteResult {
+    target: ContentTarget;
+    status: ContentWriteStatus;
+    providerId?: string;
+    warnings?: string[];
+}
+export type ContentWriteStatus = 'created' | 'updated' | 'unchanged' | 'skipped' | 'failed';

package/dist/content/provider.js

@@ -0,0 +1 @@
+export {};

package/dist/content/safeContent.d.ts

@@ -0,0 +1,2 @@
+export type ContentMap = Record<string, unknown>;
+export declare function makeSafeContentProxy<TContentMap extends ContentMap>(src: TContentMap): TContentMap;

package/dist/content/safeContent.js

@@ -0,0 +1,44 @@
+import { markRaw } from 'vue';
+const emptyArray = Object.freeze([]);
+const hasOwn = Object.prototype.hasOwnProperty;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function makeSafeContentValue(value) {
+    if (Array.isArray(value))
+        return value.map(makeSafeContentValue);
+    if (isRecord(value))
+        return makeSafeContentProxy(value);
+    return value;
+}
+export function makeSafeContentProxy(src) {
+    const handler = {
+        get(target, prop, receiver) {
+            if (hasOwn.call(target, prop)) {
+                const value = Reflect.get(target, prop, receiver);
+                if (value !== undefined)
+                    return makeSafeContentValue(value);
+            }
+            if (prop === 'length')
+                return 0;
+            if (prop === Symbol.iterator)
+                return emptyArray[Symbol.iterator].bind(emptyArray);
+            if (prop === Symbol.toPrimitive)
+                return () => '';
+            if (prop === 'toString')
+                return () => '';
+            if (prop === 'valueOf')
+                return () => '';
+            if (typeof prop === 'string' && prop.startsWith('__v_'))
+                return undefined;
+            if (typeof prop === 'string' && prop in emptyArray) {
+                const arrayValue = emptyArray[prop];
+                return typeof arrayValue === 'function' ? arrayValue.bind(emptyArray) : arrayValue;
+            }
+            if (typeof prop === 'string' && prop.startsWith('slot_'))
+                return [];
+            return makeSafeContentProxy({});
+        },
+    };
+    return markRaw(new Proxy({ ...src }, handler));
+}

package/dist/content/scope.d.ts

@@ -0,0 +1,6 @@
+import type { ContentBag } from './envelope.js';
+export declare function scopeSegment(value: string): string;
+export declare function createPageScope(slug: string): string;
+export declare function createModuleScope(subType: string, slug: string, instance?: string): string;
+export declare function scopedContentKey(scope: string, key: string): string;
+export declare function descopeContent<TContent extends ContentBag = ContentBag>(content: ContentBag, scope: string): TContent;

package/dist/content/scope.js

@@ -0,0 +1,41 @@
+export function scopeSegment(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+}
+export function createPageScope(slug) {
+    return `page_${scopeSegment(slug) || 'index'}`;
+}
+export function createModuleScope(subType, slug, instance) {
+    const base = ['module', scopeSegment(subType), scopeSegment(slug)].filter(Boolean).join('_');
+    const suffix = instance ? `_${scopeSegment(instance)}` : '';
+    return `${base || 'module'}${suffix}`;
+}
+export function scopedContentKey(scope, key) {
+    return `${scope}::${key}`;
+}
+function legacyScopedBlockAlias(key) {
+    const match = /^block_[A-Za-z][A-Za-z0-9]*_(.+)$/.exec(key);
+    return match?.[1];
+}
+export function descopeContent(content, scope) {
+    const prefix = `${scope}::`;
+    const result = {};
+    for (const [key, value] of Object.entries(content)) {
+        if (key.startsWith(prefix)) {
+            const localKey = key.slice(prefix.length);
+            result[localKey] = value;
+            const alias = legacyScopedBlockAlias(localKey);
+            if (alias && !(alias in result)) {
+                result[alias] = value;
+            }
+            continue;
+        }
+        if (!key.includes('::')) {
+            result[key] = value;
+        }
+    }
+    return result;
+}

package/dist/content/slotItems.d.ts

@@ -0,0 +1,13 @@
+import type { ContentBag, SlotItem } from './envelope.js';
+export type LayoutFallbacks = Record<string, Record<string, unknown>>;
+export type ResolvedSlotItem = SlotItem & {
+    props?: Record<string, unknown>;
+    layout?: Record<string, unknown>;
+};
+export declare function slotItemKey(item: SlotItem, index: number): string;
+export declare function moduleSlotRegistryKey(item: Extract<SlotItem, {
+    kind: 'module';
+}>): string;
+export declare function resolveSlotItems(items: SlotItem[] | null | undefined, pageContent?: ContentBag | null, layoutFallbacks?: LayoutFallbacks | null): ResolvedSlotItem[];
+export declare function resolveSlotItem(item: SlotItem, pageContent?: ContentBag | null, layoutFallbacks?: LayoutFallbacks | null): ResolvedSlotItem;
+export declare function slotItemRenderProps(item: ResolvedSlotItem): Record<string, unknown>;

package/dist/content/slotItems.js

@@ -0,0 +1,53 @@
+import { descopeContent } from './scope.js';
+export function slotItemKey(item, index) {
+    if (isModuleSlotItem(item)) {
+        return `${item.subType}/${item.slug}@${item.instanceId ?? item.instance ?? index}`;
+    }
+    const props = isRecord(item.props) ? item.props : {};
+    const key = item.key ?? props._key;
+    return typeof key === 'string' && key.length > 0 ? `${item.type}@${key}` : `${item.type}#${index}`;
+}
+export function moduleSlotRegistryKey(item) {
+    return `${item.subType}/${item.slug}`.toLowerCase();
+}
+export function resolveSlotItems(items, pageContent, layoutFallbacks) {
+    if (!Array.isArray(items))
+        return [];
+    return items.map((item) => resolveSlotItem(item, pageContent, layoutFallbacks));
+}
+export function resolveSlotItem(item, pageContent, layoutFallbacks) {
+    if (isModuleSlotItem(item)) {
+        const existingProps = optionalRecord(item, 'props');
+        return {
+            ...item,
+            props: item.scope && pageContent ? descopeContent(pageContent, item.scope) : existingProps ?? {},
+        };
+    }
+    const existingLayout = optionalRecord(item, 'layout');
+    return {
+        ...item,
+        props: item.props ?? {},
+        layout: existingLayout ?? layoutFallbacks?.[item.type] ?? {},
+    };
+}
+export function slotItemRenderProps(item) {
+    if (isModuleSlotItem(item)) {
+        return { content: item.props ?? {} };
+    }
+    return {
+        content: item.props ?? {},
+        layout: item.layout ?? {},
+    };
+}
+function isModuleSlotItem(item) {
+    return item.kind === 'module';
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function optionalRecord(value, key) {
+    if (!isRecord(value))
+        return undefined;
+    const candidate = value[key];
+    return isRecord(candidate) ? candidate : undefined;
+}

package/dist/content/targets.d.ts

@@ -0,0 +1,24 @@
+export type ContentTargetKind = 'page' | 'module' | 'global';
+export type ContentProviderName = 'local-json' | 'sanity' | 'custom';
+export type ContentTarget = PageContentTarget | ModuleContentTarget | GlobalContentTarget;
+export interface PageContentTarget {
+    kind: 'page';
+    slug: string;
+}
+export interface ModuleContentTarget {
+    kind: 'module';
+    subType: string;
+    slug: string;
+    instance?: string;
+    scope?: string;
+    providerId?: string;
+}
+export interface GlobalContentTarget {
+    kind: 'global';
+    slug: string;
+    scope?: string;
+    providerId?: string;
+}
+export declare function pageContentTarget(slug: string): PageContentTarget;
+export declare function moduleContentTarget(input: Omit<ModuleContentTarget, 'kind'>): ModuleContentTarget;
+export declare function globalContentTarget(input: Omit<GlobalContentTarget, 'kind'>): GlobalContentTarget;

package/dist/content/targets.js

@@ -0,0 +1,9 @@
+export function pageContentTarget(slug) {
+    return { kind: 'page', slug };
+}
+export function moduleContentTarget(input) {
+    return { kind: 'module', ...input };
+}
+export function globalContentTarget(input) {
+    return { kind: 'global', ...input };
+}

package/dist/index.d.ts

@@ -1 +1,2 @@
 export * from './design-system/index.js';
+export * from './content/index.js';

package/dist/index.js

@@ -1 +1,2 @@
 export * from './design-system/index.js';
+export * from './content/index.js';

package/dist/schema/LayoutDefinitionMeta.d.ts

@@ -1,6 +1,7 @@
 import type { BindingEditorPolicy } from './LayoutBindingEditorPolicyMetadata.js';
 import type { BindingEditorSection } from './LayoutBindingEditorSectionMetadata.js';
 import type { LayoutFieldUiMeta } from './LayoutFieldUiMetadata.js';
+import type { AuthoringEffectKind } from '../authoring/index.js';
 export type LayoutFieldAuthoringNumberValue = {
     kind: 'number';
     min?: number;
@@ -10,11 +11,14 @@ export type LayoutFieldAuthoringNumberValue = {
 export type LayoutFieldAuthoringMeta = {
     sourceKind: 'coreToken';
     ops: string[];
+    tokenFamily?: string;
     surface: 'css' | 'responsive';
+    effectKinds?: AuthoringEffectKind[];
 } | {
     sourceKind: 'declaredToken';
     designOp?: string;
     tokenFamily?: string;
+    effectKinds?: AuthoringEffectKind[];
 } | {
     sourceKind: 'enum';
 } | {
@@ -28,11 +32,13 @@ export type LayoutFieldAuthoringMeta = {
     designOp?: string;
     tokenFamily?: string;
     surface?: 'css' | 'responsive';
+    effectKinds?: AuthoringEffectKind[];
     authoringValue?: LayoutFieldAuthoringNumberValue;
 } | {
     sourceKind: 'valueEnum';
     designOp?: string;
     tokenFamily?: string;
+    effectKinds?: AuthoringEffectKind[];
 } | {
     sourceKind: 'wrapper';
 } | {

package/dist/shared/legacyNames.d.ts

@@ -0,0 +1,6 @@
+export declare const LEGACY_NAME_LOWER: string;
+export declare const LEGACY_NAME_UPPER: string;
+export declare const LEGACY_PRIVATE_DIR: string;
+export declare const LEGACY_PUBLIC_DIR: string;
+export declare const LEGACY_CONFIG_FILE: string;
+export declare function legacyContract(suffix: string): string;

package/dist/shared/legacyNames.js

@@ -0,0 +1,8 @@
+export const LEGACY_NAME_LOWER = ['tun', 'dra'].join('');
+export const LEGACY_NAME_UPPER = LEGACY_NAME_LOWER.toUpperCase();
+export const LEGACY_PRIVATE_DIR = `.${LEGACY_NAME_LOWER}`;
+export const LEGACY_PUBLIC_DIR = `__${LEGACY_NAME_LOWER}`;
+export const LEGACY_CONFIG_FILE = `${LEGACY_NAME_LOWER}.json`;
+export function legacyContract(suffix) {
+    return `${LEGACY_NAME_LOWER}.${suffix}`;
+}

package/dist/static/buildSsg.d.ts

@@ -0,0 +1,11 @@
+export type StaticSsgBuildArgs = {
+    configFile: string;
+    mode: string;
+    outDir: string;
+};
+export type StaticSsgBuildOptions = {
+    cwd?: string;
+};
+export declare function parseStaticSsgBuildArgs(argv: string[]): StaticSsgBuildArgs;
+export declare function buildStaticSsg(args?: Partial<StaticSsgBuildArgs>, options?: StaticSsgBuildOptions): Promise<void>;
+export declare function runStaticSsgBuildCli(argv?: string[]): Promise<void>;