everything-dev 0.3.2 → 1.3.2

package/src/types.ts

@@ -1,234 +1,180 @@
-import { z } from "every-plugin/zod";
+import { z } from "./sdk";
 
 export const SourceModeSchema = z.enum(["local", "remote"]);
 export type SourceMode = z.infer<typeof SourceModeSchema>;
 
-export const HostConfigSchema = z.object({
-	development: z.string(),
-	production: z.string(),
-	secrets: z.array(z.string()).optional(),
-	template: z.string().optional(),
-	files: z.array(z.string()).optional(),
-	sync: z.lazy(() => SyncConfigSchema).optional(),
-});
-export type HostConfig = z.infer<typeof HostConfigSchema>;
-
-export const RemoteConfigSchema = z.object({
-	name: z.string(),
-	development: z.string(),
-	production: z.string(),
-	ssr: z.string().optional(),
-	proxy: z.string().optional(),
-	variables: z.record(z.string(), z.string()).optional(),
-	secrets: z.array(z.string()).optional(),
-	template: z.string().optional(),
-	files: z.array(z.string()).optional(),
-	sync: z.lazy(() => SyncConfigSchema).optional(),
-});
-export type RemoteConfig = z.infer<typeof RemoteConfigSchema>;
-
-/**
- * Partial RemoteConfig for input configs (child configs that extend a base).
- * Only 'name' is required; development/production can be inherited.
- */
-export const PartialRemoteConfigSchema = z.object({
-	name: z.string(),
-	development: z.string().optional(),
-	production: z.string().optional(),
-	proxy: z.string().optional(),
-	variables: z.record(z.string(), z.string()).optional(),
-	secrets: z.array(z.string()).optional(),
-	template: z.string().optional(),
-	files: z.array(z.string()).optional(),
-	sync: z.lazy(() => SyncConfigSchema).optional(),
-});
-export type PartialRemoteConfig = z.infer<typeof PartialRemoteConfigSchema>;
-
-export const NovaConfigSchema = z.object({
-	account: z.string(),
+export const SharedConfigSchema = z.object({
+  version: z.string(),
+  requiredVersion: z.string().optional(),
+  singleton: z.boolean().optional(),
+  eager: z.boolean().optional(),
+  strictVersion: z.boolean().optional(),
+  shareScope: z.string().optional(),
 });
-export type NovaConfig = z.infer<typeof NovaConfigSchema>;
+export type SharedConfig = z.infer<typeof SharedConfigSchema>;
+export type SharedDepConfig = SharedConfig;
+export const SharedDepConfigSchema = SharedConfigSchema;
 
-export const GatewayConfigSchema = z.object({
-	development: z.string(),
-	production: z.string(),
-	account: z.string().optional(),
-	nova: NovaConfigSchema.optional(),
+export const FederationEntrySchema = z.object({
+  name: z.string(),
+  url: z.string(),
+  entry: z.string(),
+  source: SourceModeSchema,
+  integrity: z.string().optional(),
 });
-export type GatewayConfig = z.infer<typeof GatewayConfigSchema>;
+export type FederationEntry = z.infer<typeof FederationEntrySchema>;
 
-export const SharedDepConfigSchema = z.object({
-	requiredVersion: z.string().optional(),
-	singleton: z.boolean().optional(),
-	eager: z.boolean().optional(),
-	strictVersion: z.boolean().optional(),
+export const ApiPluginConfigSchema = z.object({
+  name: z.string(),
+  development: z.string().optional(),
+  production: z.string().optional(),
+  productionIntegrity: z.string().optional(),
+  proxy: z.string().optional(),
+  variables: z.record(z.string(), z.string()).optional(),
+  secrets: z.array(z.string()).optional(),
 });
-export type SharedDepConfig = z.infer<typeof SharedDepConfigSchema>;
-
-export const SyncConfigSchema = z.object({
-	scripts: z.union([z.array(z.string()), z.literal(true)]).optional(),
-	dependencies: z.boolean().default(true),
-	devDependencies: z.boolean().default(true),
+export type ApiPluginConfig = z.infer<typeof ApiPluginConfigSchema>;
+
+export const BosPluginRefSchema = z.object({
+  extends: z.string().optional(),
+  development: z.string().optional(),
+  production: z.string().optional(),
+  productionIntegrity: z.string().optional(),
+  proxy: z.string().optional(),
+  variables: z.record(z.string(), z.string()).optional(),
+  secrets: z.array(z.string()).optional(),
 });
-export type SyncConfig = z.infer<typeof SyncConfigSchema>;
-
-export const BosConfigSchema = z.object({
-	extends: z.string().optional(),
-	account: z.string(),
-	testnet: z.string().optional(),
-	nova: NovaConfigSchema.optional(),
-	gateway: GatewayConfigSchema,
-	template: z.string().optional(),
-	cli: z
-		.object({
-			version: z.string().optional(),
-		})
-		.optional(),
-	shared: z
-		.record(z.string(), z.record(z.string(), SharedDepConfigSchema))
-		.optional(),
-	app: z
-		.object({
-			host: HostConfigSchema,
-		})
-		.catchall(z.union([RemoteConfigSchema, HostConfigSchema])),
+export type BosPluginRef = z.infer<typeof BosPluginRefSchema>;
+
+export const RuntimePluginConfigSchema = z.object({
+  name: z.string(),
+  url: z.string(),
+  entry: z.string(),
+  source: SourceModeSchema,
+  localPath: z.string().optional(),
+  port: z.number().optional(),
+  proxy: z.string().optional(),
+  variables: z.record(z.string(), z.string()).optional(),
+  secrets: z.array(z.string()).optional(),
+  integrity: z.string().optional(),
 });
-export type BosConfig = z.infer<typeof BosConfigSchema>;
-
-/**
- * BosConfigInputSchema - permissive schema for parsing input configs.
- * Supports extends and allows partial app configs (child overrides only what it needs).
- * After resolving extends, the result must be validated against the strict BosConfigSchema.
- */
-export const BosConfigInputSchema = z.object({
-	extends: z.string().optional(),
-	account: z.string().optional(),
-	testnet: z.string().optional(),
-	nova: NovaConfigSchema.optional(),
-	gateway: GatewayConfigSchema.optional(),
-	template: z.string().optional(),
-	cli: z
-		.object({
-			version: z.string().optional(),
-		})
-		.optional(),
-	shared: z
-		.record(z.string(), z.record(z.string(), SharedDepConfigSchema))
-		.optional(),
-	app: z
-		.object({
-			host: HostConfigSchema.optional(),
-			ui: PartialRemoteConfigSchema.optional(),
-			api: PartialRemoteConfigSchema.optional(),
-		})
-		.partial()
-		.catchall(z.union([HostConfigSchema, PartialRemoteConfigSchema])),
+export type RuntimePluginConfig = z.infer<typeof RuntimePluginConfigSchema>;
+
+export const UiConfigSchema = z.object({
+  name: z.string(),
+  development: z.string().optional(),
+  production: z.string().optional(),
+  productionIntegrity: z.string().optional(),
+  ssr: z.string().optional(),
+  ssrIntegrity: z.string().optional(),
 });
-export type BosConfigInput = z.infer<typeof BosConfigInputSchema>;
+export type UiConfig = z.infer<typeof UiConfigSchema>;
 
-export const AppConfigSchema = z.object({
-	host: SourceModeSchema,
-	ui: SourceModeSchema,
-	api: SourceModeSchema,
-	proxy: z.boolean().optional(),
+export const HostConfigSchema = z.object({
+  development: z.string(),
+  production: z.string(),
+  productionIntegrity: z.string().optional(),
+  secrets: z.array(z.string()).optional(),
 });
-export type AppConfig = z.infer<typeof AppConfigSchema>;
+export type HostConfig = z.infer<typeof HostConfigSchema>;
 
-export const PortConfigSchema = z.object({
-	host: z.number(),
-	ui: z.number(),
-	api: z.number(),
+export const ClientRuntimeInfoSchema = z.object({
+  accountId: z.string(),
+  gatewayId: z.string(),
+  runtimeBasePath: z.string(),
+  title: z.string().nullable(),
+  hostUrl: z.string().nullable(),
 });
-export type PortConfig = z.infer<typeof PortConfigSchema>;
+export type ClientRuntimeInfo = z.infer<typeof ClientRuntimeInfoSchema>;
 
-export const SharedConfigSchema = z.object({
-	requiredVersion: z.string().optional(),
-	singleton: z.boolean().optional(),
-	eager: z.boolean().optional(),
-	strictVersion: z.boolean().optional(),
-	shareScope: z.string().optional(),
+export const BosStagingSchema = z.object({
+  domain: z.string(),
 });
-export type SharedConfig = z.infer<typeof SharedConfigSchema>;
+export type BosStaging = z.infer<typeof BosStagingSchema>;
 
-/**
- * Federation entry info - both base URL and computed manifest entry
- */
-export const FederationEntrySchema = z.object({
-	name: z.string(),
-	url: z.string(), // Base/assets URL
-	entry: z.string(), // Computed federation entry (mf-manifest.json or remoteEntry.js)
-	source: SourceModeSchema,
+export const BosConfigSchema = z.object({
+  account: z.string(),
+  extends: z.string().optional(),
+  domain: z.string().optional(),
+  testnet: z.string().optional(),
+  staging: BosStagingSchema.optional(),
+  repository: z.string().optional(),
+  shared: z.record(z.string(), z.record(z.string(), SharedConfigSchema)).optional(),
+  plugins: z.record(z.string(), BosPluginRefSchema).optional(),
+  app: z.object({
+    host: HostConfigSchema,
+    ui: UiConfigSchema,
+    api: ApiPluginConfigSchema,
+  }),
 });
-export type FederationEntry = z.infer<typeof FederationEntrySchema>;
+export type BosConfig = z.infer<typeof BosConfigSchema>;
 
 export const RuntimeConfigSchema = z.object({
-	env: z.enum(["development", "production"]),
-	account: z.string(),
-	title: z.string().optional(),
-	hostUrl: z.string(),
-	shared: z
-		.object({
-			ui: z.record(z.string(), SharedConfigSchema).optional(),
-		})
-		.optional(),
-	ui: FederationEntrySchema.extend({
-		ssrUrl: z.string().optional(),
-	}),
-	api: FederationEntrySchema.extend({
-		proxy: z.string().optional(),
-		variables: z.record(z.string(), z.string()).optional(),
-		secrets: z.array(z.string()).optional(),
-	}),
+  env: z.enum(["development", "production"]),
+  account: z.string(),
+  domain: z.string().optional(),
+  networkId: z.enum(["mainnet", "testnet"]),
+  title: z.string().optional(),
+  repository: z.string().optional(),
+  hostUrl: z.string(),
+  shared: z
+    .object({
+      ui: z.record(z.string(), SharedConfigSchema).optional(),
+    })
+    .optional(),
+  ui: FederationEntrySchema.extend({
+    localPath: z.string().optional(),
+    port: z.number().optional(),
+    ssrUrl: z.string().optional(),
+    ssrIntegrity: z.string().optional(),
+  }),
+  api: FederationEntrySchema.extend({
+    localPath: z.string().optional(),
+    port: z.number().optional(),
+    proxy: z.string().optional(),
+    variables: z.record(z.string(), z.string()).optional(),
+    secrets: z.array(z.string()).optional(),
+  }),
+  plugins: z.record(z.string(), RuntimePluginConfigSchema).optional(),
 });
 export type RuntimeConfig = z.infer<typeof RuntimeConfigSchema>;
 
-/**
- * Client-side runtime config (injected via window.__RUNTIME_CONFIG__)
- * Contains federation entry info so browser can load remotes via manifest
- */
 export const ClientRuntimeConfigSchema = z.object({
-	env: z.enum(["development", "production"]),
-	account: z.string(),
-	hostUrl: z.string().optional(),
-	assetsUrl: z.string(), // Legacy: use ui.entry for MF loading
-	apiBase: z.string(),
-	rpcBase: z.string(),
-	ui: z
-		.object({
-			name: z.string(),
-			url: z.string(), // Base URL for assets
-			entry: z.string(), // Federation entry (mf-manifest.json)
-		})
-		.optional(),
+  env: z.enum(["development", "production"]),
+  account: z.string(),
+  networkId: z.enum(["mainnet", "testnet"]),
+  hostUrl: z.string().optional(),
+  assetsUrl: z.string(),
+  apiBase: z.string(),
+  rpcBase: z.string(),
+  repository: z.string().optional(),
+  runtime: ClientRuntimeInfoSchema.optional(),
+  ui: z
+    .object({
+      name: z.string(),
+      url: z.string(),
+      entry: z.string(),
+      integrity: z.string().optional(),
+    })
+    .optional(),
+  api: z
+    .object({
+      name: z.string(),
+      url: z.string(),
+      entry: z.string(),
+      integrity: z.string().optional(),
+    })
+    .optional(),
+  plugins: z
+    .record(
+      z.string(),
+      z.object({
+        name: z.string(),
+        url: z.string(),
+        entry: z.string(),
+        integrity: z.string().optional(),
+      }),
+    )
+    .optional(),
 });
 export type ClientRuntimeConfig = z.infer<typeof ClientRuntimeConfigSchema>;
-
-/**
- * Error thrown when a circular extends dependency is detected
- */
-export class ConfigCircularExtendsError extends Error {
-	constructor(chain: string[]) {
-		super(`Circular extends detected: ${chain.join(" → ")}`);
-		this.name = "ConfigCircularExtendsError";
-	}
-}
-
-/**
- * Error thrown when config fetching fails
- */
-export class ConfigFetchError extends Error {
-	constructor(url: string, cause: unknown) {
-		super(`Failed to fetch config from ${url}: ${cause}`);
-		this.name = "ConfigFetchError";
-	}
-}
-
-/**
- * Error thrown when config resolution fails
- */
-export class ConfigResolutionError extends Error {
-	constructor(message: string) {
-		super(message);
-		this.name = "ConfigResolutionError";
-	}
-}

package/src/ui/head.ts

@@ -2,31 +2,38 @@ import type { ClientRuntimeConfig } from "../types";
 import type { HeadScript } from "./types";
 
 export interface RemoteScriptsOptions {
-	assetsUrl: string;
-	runtimeConfig?: ClientRuntimeConfig;
-	containerName?: string;
-	hydratePath?: string;
+  assetsUrl: string;
+  runtimeConfig?: Partial<ClientRuntimeConfig>;
+  containerName?: string;
+  hydratePath?: string;
+  integrity?: string;
 }
 
-export function getRemoteEntryScript(assetsUrl: string): HeadScript {
-	return {
-		src: `${assetsUrl}/remoteEntry.js`,
-	};
+export function getRemoteEntryScript(assetsUrl: string, integrity?: string): HeadScript {
+  const script: HeadScript = {
+    src: `${assetsUrl}/remoteEntry.js`,
+  };
+  if (integrity) {
+    script.integrity = integrity;
+    script.crossOrigin = "anonymous";
+  }
+  return script;
 }
 
 export function getThemeInitScript(): HeadScript {
-	return {
-		children: `(function(){var t=localStorage.getItem('theme');if(t==='dark'||(!t&&window.matchMedia('(prefers-color-scheme: dark)').matches)){document.documentElement.classList.add('dark');}})();`,
-	};
+  return {
+    children:
+      "(function(){var t=localStorage.getItem('theme');if(t==='dark'||(!t&&window.matchMedia('(prefers-color-scheme: dark)').matches)){document.documentElement.classList.add('dark');}})();",
+  };
 }
 
 export function getHydrateScript(
-	runtimeConfig: ClientRuntimeConfig | undefined,
-	containerName = "ui",
-	hydratePath = "./Hydrate",
+  runtimeConfig: Partial<ClientRuntimeConfig> | undefined,
+  containerName = "ui",
+  hydratePath = "./Hydrate",
 ): HeadScript {
-	return {
-		children: `
+  return {
+    children: `
  window.__RUNTIME_CONFIG__=${JSON.stringify(runtimeConfig)};
  function __hydrate(){
   var container = window['${containerName}'];
@@ -49,24 +56,24 @@ export function getHydrateScript(
   }).catch(function(e){
     console.error('[Hydrate] Failed:', e);
   });
-}
-if(document.readyState==='loading'){document.addEventListener('DOMContentLoaded',__hydrate);}else{__hydrate();}
-    `.trim(),
-	};
+ }
+ if(document.readyState==='loading'){document.addEventListener('DOMContentLoaded',__hydrate);}else{__hydrate();}
+ 		`.trim(),
+  };
 }
 
 export function getRemoteScripts(options: RemoteScriptsOptions): HeadScript[] {
-	const { assetsUrl, runtimeConfig, containerName, hydratePath } = options;
+  const { assetsUrl, runtimeConfig, containerName, hydratePath, integrity } = options;
 
-	return [
-		getRemoteEntryScript(assetsUrl),
-		getThemeInitScript(),
-		getHydrateScript(runtimeConfig, containerName, hydratePath),
-	];
+  return [
+    getRemoteEntryScript(assetsUrl, integrity),
+    getThemeInitScript(),
+    getHydrateScript(runtimeConfig, containerName, hydratePath),
+  ];
 }
 
 export function getBaseStyles(): string {
-	return `
+  return `
 *, *::before, *::after { box-sizing: border-box; }
 html { height: 100%; height: 100dvh; -webkit-text-size-adjust: 100%; text-size-adjust: 100%; color-scheme: light dark; }
 body { min-height: 100%; min-height: 100dvh; margin: 0; background-color: var(--background); color: var(--foreground); -webkit-tap-highlight-color: transparent; touch-action: manipulation; }

package/src/ui/index.ts

@@ -1,5 +1,5 @@
-export * from "./types";
-export * from "./runtime";
 export * from "./head";
-export * from "./files";
+export * from "./metadata";
 export * from "./router";
+export * from "./runtime";
+export * from "./types";

package/src/ui/metadata.ts

@@ -0,0 +1,95 @@
+export const SOCIAL_IMAGE_WIDTH = 1200;
+export const SOCIAL_IMAGE_HEIGHT = 630;
+
+export interface SocialImageMetaOptions {
+  imageUrl: string;
+  title: string;
+  description: string;
+  siteName?: string;
+  siteUrl?: string;
+  type?: string;
+  alt?: string;
+  width?: number;
+  height?: number;
+  mimeType?: string;
+}
+
+export function getSocialImageMeta(options: SocialImageMetaOptions) {
+  const {
+    imageUrl,
+    title,
+    description,
+    siteName,
+    siteUrl,
+    type = "website",
+    alt,
+    width = SOCIAL_IMAGE_WIDTH,
+    height = SOCIAL_IMAGE_HEIGHT,
+    mimeType = "image/png",
+  } = options;
+
+  return [
+    { property: "og:title", content: title },
+    { property: "og:description", content: description },
+    { property: "og:type", content: type },
+    { property: "og:image", content: imageUrl },
+    { property: "og:image:type", content: mimeType },
+    { property: "og:image:width", content: String(width) },
+    { property: "og:image:height", content: String(height) },
+    ...(alt ? [{ property: "og:image:alt", content: alt }] : []),
+    ...(siteName ? [{ property: "og:site_name", content: siteName }] : []),
+    ...(siteUrl ? [{ property: "og:url", content: siteUrl }] : []),
+    { name: "twitter:card", content: "summary_large_image" },
+    { name: "twitter:title", content: title },
+    { name: "twitter:description", content: description },
+    { name: "twitter:image", content: imageUrl },
+    ...(alt ? [{ name: "twitter:image:alt", content: alt }] : []),
+  ];
+}
+
+export interface DotIconSvgOptions {
+  size?: number;
+  color?: string;
+  radius?: number;
+  background?: string;
+}
+
+export function createDotIconSvg(options: DotIconSvgOptions = {}) {
+  const {
+    size = 64,
+    color = "#111111",
+    radius = size * 0.34,
+    background = "transparent",
+  } = options;
+  const center = size / 2;
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="${size}" height="${size}" viewBox="0 0 ${size} ${size}">
+  <rect width="${size}" height="${size}" fill="${background}" />
+  <circle cx="${center}" cy="${center}" r="${radius}" fill="${color}" />
+</svg>`;
+}
+
+export function createPngIcoBuffer(png: Uint8Array, width: number, height: number) {
+  const header = new Uint8Array(22);
+  const view = new DataView(header.buffer);
+
+  view.setUint16(0, 0, true);
+  view.setUint16(2, 1, true);
+  view.setUint16(4, 1, true);
+
+  header[6] = width >= 256 ? 0 : width;
+  header[7] = height >= 256 ? 0 : height;
+  header[8] = 0;
+  header[9] = 0;
+
+  view.setUint16(10, 1, true);
+  view.setUint16(12, 32, true);
+  view.setUint32(14, png.byteLength, true);
+  view.setUint32(18, 22, true);
+
+  const ico = new Uint8Array(22 + png.byteLength);
+  ico.set(header, 0);
+  ico.set(png, 22);
+  return ico;
+}

package/src/ui/router.ts

@@ -6,8 +6,12 @@ export function getMetaKey(meta: HeadMeta): string {
   if ("title" in meta) return "title";
   if ("charSet" in meta) return "charSet";
   if ("name" in meta) return `name:${(meta as { name: string }).name}`;
-  if ("property" in meta) return `property:${(meta as { property: string }).property}`;
-  if ("httpEquiv" in meta) return `httpEquiv:${(meta as { httpEquiv: string }).httpEquiv}`;
+  if ("property" in meta) {
+    return `property:${(meta as { property: string }).property}`;
+  }
+  if ("httpEquiv" in meta) {
+    return `httpEquiv:${(meta as { httpEquiv: string }).httpEquiv}`;
+  }
   return JSON.stringify(meta);
 }
 
@@ -20,8 +24,9 @@ export function getLinkKey(link: HeadLink): string {
 export function getScriptKey(script: HeadScript): string {
   if (!script) return "null";
   if ("src" in script && script.src) return `src:${script.src}`;
-  if ("children" in script && script.children)
+  if ("children" in script && script.children) {
     return `children:${typeof script.children === "string" ? script.children : JSON.stringify(script.children)}`;
+  }
   return JSON.stringify(script);
 }
 
@@ -33,16 +38,27 @@ export async function collectHeadData(router: AnyRouter): Promise<HeadData> {
   const scriptMap = new Map<string, HeadScript>();
 
   for (const match of router.state.matches) {
-    const headFn = match.route?.options?.head;
+    const route =
+      (
+        router as AnyRouter & {
+          routesById?: Record<string, { options?: { head?: (...args: unknown[]) => unknown } }>;
+        }
+      ).routesById?.[(match as { routeId: string }).routeId] ??
+      (match as { route?: { options?: { head?: (...args: unknown[]) => unknown } } }).route;
+    const headFn = route?.options?.head;
     if (!headFn) continue;
 
     try {
-      const headResult = await headFn({
+      const headResult = (await headFn({
         loaderData: match.loaderData,
         matches: router.state.matches,
         match,
         params: match.params,
-      } as Parameters<typeof headFn>[0]);
+      })) as {
+        meta?: HeadMeta[];
+        links?: HeadLink[];
+        scripts?: HeadScript[];
+      };
 
       if (headResult?.meta) {
         for (const meta of headResult.meta) {