wesper 0.0.1

package/dist/chunk-44KKIZUQ.js

@@ -0,0 +1,754 @@
+// src/types.ts
+var CONTEXT_VERSION = 1;
+var SCHEMA_URL = "https://humanmade.github.io/wesper/schemas/site-context-v1.schema.json";
+
+// src/schema.ts
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+var jsonValueSchema = z.lazy(
+  () => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(jsonValueSchema),
+    z.record(z.string(), jsonValueSchema)
+  ])
+);
+var warningSeveritySchema = z.enum(["info", "warning", "error"]);
+var contextWarningSchema = z.object({
+  code: z.string().min(1),
+  severity: warningSeveritySchema,
+  message: z.string().min(1),
+  surface: z.string().min(1)
+});
+var validationIssueSchema = z.object({
+  path: z.string(),
+  message: z.string()
+});
+var tokenSchema = z.object({
+  slug: z.string().min(1),
+  name: z.string().optional(),
+  value: z.string().min(1)
+}).passthrough();
+var bindingSourceSchema = z.object({
+  name: z.string().min(1),
+  label: z.string().nullable().optional(),
+  usesContext: z.array(z.string()).default([]),
+  argsSchema: jsonValueSchema.nullable().default(null)
+}).passthrough();
+var bindingFieldSchema = z.object({
+  key: z.string().min(1),
+  source: z.string().min(1),
+  type: z.string().optional(),
+  single: z.boolean().optional(),
+  showInRest: z.boolean().optional(),
+  bindable: z.boolean().default(true)
+}).passthrough();
+var siteContextSchema = z.object({
+  $schema: z.string().url().default(SCHEMA_URL),
+  contextVersion: z.literal(CONTEXT_VERSION),
+  site: z.object({
+    url: z.string().optional(),
+    name: z.string().optional(),
+    environment: z.enum(["local", "staging", "production", "unknown"]).default("unknown"),
+    isMultisite: z.boolean().default(false)
+  }).passthrough(),
+  provenance: z.object({
+    collectedAt: z.string().datetime(),
+    collector: z.enum(["wp-cli", "fixture"]),
+    collectorVersion: z.string().min(1),
+    sourceHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    partial: z.boolean().default(false)
+  }).passthrough(),
+  wordpress: z.object({
+    version: z.string().optional(),
+    locale: z.string().optional(),
+    permalinkStructure: z.string().optional(),
+    features: z.record(z.string(), z.boolean()).default({})
+  }).passthrough(),
+  theme: z.object({
+    stylesheet: z.string().optional(),
+    template: z.string().optional(),
+    name: z.string().optional(),
+    version: z.string().optional(),
+    isBlockTheme: z.boolean().optional(),
+    themeJsonHash: z.string().optional(),
+    settingsOrigin: z.enum(["merged", "theme"]).default("merged"),
+    tokens: z.object({
+      colors: z.array(tokenSchema).default([]),
+      spacing: z.array(tokenSchema).default([]),
+      typography: z.array(tokenSchema).default([])
+    }).default({ colors: [], spacing: [], typography: [] }),
+    settings: jsonValueSchema.optional()
+  }).passthrough(),
+  plugins: z.array(z.record(z.string(), jsonValueSchema)).default([]),
+  blocks: z.object({
+    types: z.array(z.record(z.string(), jsonValueSchema)).default([])
+  }).passthrough(),
+  bindings: z.object({
+    available: z.boolean().default(false),
+    sources: z.array(bindingSourceSchema).default([]),
+    supportedAttributes: z.record(z.string(), z.array(z.string())).default({}),
+    warnings: z.array(contextWarningSchema).default([])
+  }).passthrough(),
+  contentModel: z.object({
+    postTypes: z.array(
+      z.object({
+        name: z.string().min(1),
+        label: z.string().optional(),
+        public: z.boolean().optional(),
+        showInRest: z.boolean().optional(),
+        taxonomies: z.array(z.string()).default([]),
+        fields: z.array(bindingFieldSchema).default([])
+      }).passthrough()
+    ).default([])
+  }).passthrough(),
+  patterns: z.object({
+    items: z.array(z.record(z.string(), jsonValueSchema)).default([])
+  }).passthrough(),
+  media: z.object({
+    imageSizes: z.array(z.record(z.string(), jsonValueSchema)).default([]),
+    maxUploadSize: z.number().optional()
+  }).passthrough(),
+  warnings: z.array(contextWarningSchema).default([])
+}).passthrough();
+var summarySchema = z.object({
+  site: z.object({
+    url: z.string().optional(),
+    wordpressVersion: z.string().optional(),
+    theme: z.string().optional(),
+    collector: z.string(),
+    collectedAt: z.string(),
+    sourceHash: z.string()
+  }),
+  counts: z.object({
+    blockTypes: z.number(),
+    bindingSources: z.number(),
+    postTypes: z.number(),
+    bindableFields: z.number(),
+    patterns: z.number(),
+    plugins: z.number(),
+    imageSizes: z.number(),
+    warnings: z.number()
+  }),
+  bindingReadiness: z.object({
+    supportedAttributes: z.record(z.string(), z.array(z.string())),
+    fieldsByPostType: z.record(z.string(), z.number())
+  }),
+  warningsBySurface: z.record(z.string(), z.array(contextWarningSchema))
+});
+var siteContextJsonSchema = zodToJsonSchema(siteContextSchema, {
+  name: "WesperSiteContextV1",
+  $refStrategy: "root",
+  target: "jsonSchema7"
+});
+
+// src/canonical.ts
+import { createHash } from "node:crypto";
+
+// src/redact.ts
+var SECRET_KEY_PATTERN = /(^|[_-])(password|passwd|pwd|secret|authorization|cookie|nonce|credential)($|[_-])|app[_-]?password|api[_-]?key|access[_-]?token|refresh[_-]?token|auth[_-]?token|bearer/i;
+var REDACTED = "[REDACTED]";
+function redactSecrets(value) {
+  return redact(value);
+}
+function redact(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => redact(item));
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const result = {};
+  for (const [key, nested] of Object.entries(value)) {
+    result[key] = SECRET_KEY_PATTERN.test(key) ? REDACTED : redact(nested);
+  }
+  return result;
+}
+
+// src/canonical.ts
+function canonicalize(value) {
+  return JSON.stringify(sortJson(value));
+}
+function sourceHash(value) {
+  const hash = createHash("sha256");
+  hash.update(canonicalize(redactSecrets(withoutVolatileProvenance(value))));
+  return `sha256:${hash.digest("hex")}`;
+}
+function withoutVolatileProvenance(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return value;
+  }
+  const clone = structuredClone(value);
+  const provenance = clone.provenance;
+  if (provenance && typeof provenance === "object" && !Array.isArray(provenance)) {
+    delete provenance.collectedAt;
+    delete provenance.sourceHash;
+  }
+  return clone;
+}
+function sortJson(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sortJson(item));
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, nested]) => [key, sortJson(nested)])
+  );
+}
+
+// src/theme.ts
+function parseThemeJsonSettings(settings) {
+  const tokens = { colors: [], spacing: [], typography: [] };
+  if (!settings || typeof settings !== "object") {
+    return tokens;
+  }
+  const typed = settings;
+  for (const entry of presetEntries(typed.color?.palette)) {
+    if (entry.slug && entry.color) {
+      tokens.colors.push(token(entry.slug, entry.color, entry.name));
+    }
+  }
+  for (const entry of presetEntries(typed.typography?.fontFamilies)) {
+    if (entry.slug && entry.fontFamily) {
+      tokens.typography.push(token(entry.slug, entry.fontFamily, entry.name));
+    }
+  }
+  for (const entry of presetEntries(typed.typography?.fontSizes)) {
+    if (entry.slug && entry.size) {
+      tokens.typography.push(token(entry.slug, entry.size, entry.name));
+    }
+  }
+  for (const entry of presetEntries(typed.spacing?.spacingSizes)) {
+    if (entry.slug && entry.size) {
+      tokens.spacing.push(token(entry.slug, entry.size, entry.name));
+    }
+  }
+  tokens.colors.sort(bySlug);
+  tokens.spacing.sort(bySlug);
+  tokens.typography.sort(bySlug);
+  return tokens;
+}
+function themeWarnings(settings) {
+  if (!settings || typeof settings !== "object") {
+    return [
+      {
+        code: "theme.settings_unavailable",
+        severity: "warning",
+        surface: "theme.settings",
+        message: "Theme settings could not be normalized."
+      }
+    ];
+  }
+  return [];
+}
+function token(slug, value, name) {
+  return name ? { slug, name, value } : { slug, value };
+}
+function presetEntries(collection) {
+  if (Array.isArray(collection)) {
+    return collection;
+  }
+  if (!collection || typeof collection !== "object") {
+    return [];
+  }
+  return Object.values(collection).flatMap((value) => Array.isArray(value) ? value : []);
+}
+function bySlug(left, right) {
+  return left.slug.localeCompare(right.slug);
+}
+
+// src/warnings.ts
+function allWarnings(context) {
+  return [...context.warnings, ...context.bindings.warnings ?? []];
+}
+function actionableWarnings(warnings) {
+  return warnings.filter((warning) => warning.severity !== "info");
+}
+function hasActionableWarnings(warnings) {
+  return actionableWarnings(warnings).length > 0;
+}
+
+// src/summary.ts
+function summarize(context) {
+  const postTypes = context.contentModel.postTypes ?? [];
+  const fieldsByPostType = Object.fromEntries(
+    postTypes.map((postType) => [postType.name, postType.fields?.filter((field) => field.bindable).length ?? 0])
+  );
+  const warnings = allWarnings(context);
+  return {
+    site: {
+      url: context.site.url,
+      wordpressVersion: context.wordpress.version,
+      theme: context.theme.name ?? context.theme.stylesheet,
+      collector: context.provenance.collector,
+      collectedAt: context.provenance.collectedAt,
+      sourceHash: context.provenance.sourceHash
+    },
+    counts: {
+      blockTypes: context.blocks.types?.length ?? 0,
+      bindingSources: context.bindings.sources?.length ?? 0,
+      postTypes: postTypes.length,
+      bindableFields: Object.values(fieldsByPostType).reduce((sum, count) => sum + count, 0),
+      patterns: context.patterns.items?.length ?? 0,
+      plugins: context.plugins.length,
+      imageSizes: context.media.imageSizes?.length ?? 0,
+      warnings: warnings.length
+    },
+    bindingReadiness: {
+      supportedAttributes: context.bindings.supportedAttributes ?? {},
+      fieldsByPostType
+    },
+    warningsBySurface: groupWarnings(warnings)
+  };
+}
+function formatSummaryMarkdown(context) {
+  const summary = summarize(context);
+  const lines = [
+    `# Wesper Context Summary`,
+    ``,
+    `- Site: ${summary.site.url ?? "unknown"}`,
+    `- WordPress: ${summary.site.wordpressVersion ?? "unknown"}`,
+    `- Theme: ${summary.site.theme ?? "unknown"}`,
+    `- Collector: ${summary.site.collector}`,
+    `- Source hash: ${summary.site.sourceHash}`,
+    ``,
+    `## Counts`,
+    ``,
+    `- Block types: ${summary.counts.blockTypes}`,
+    `- Binding sources: ${summary.counts.bindingSources}`,
+    `- Post types: ${summary.counts.postTypes}`,
+    `- Bindable fields: ${summary.counts.bindableFields}`,
+    `- Patterns: ${summary.counts.patterns}`,
+    `- Plugins: ${summary.counts.plugins}`,
+    `- Image sizes: ${summary.counts.imageSizes}`,
+    `- Warnings: ${summary.counts.warnings}`,
+    ``,
+    `## Binding Readiness`,
+    ``
+  ];
+  for (const [blockName, attributes] of Object.entries(summary.bindingReadiness.supportedAttributes).sort()) {
+    lines.push(`- ${blockName}: ${attributes.join(", ") || "none"}`);
+  }
+  if (Object.keys(summary.bindingReadiness.supportedAttributes).length === 0) {
+    lines.push("- No supported binding attributes reported.");
+  }
+  lines.push("", "## Fields By Post Type", "");
+  for (const [postType, count] of Object.entries(summary.bindingReadiness.fieldsByPostType).sort()) {
+    lines.push(`- ${postType}: ${count}`);
+  }
+  if (Object.keys(summary.bindingReadiness.fieldsByPostType).length === 0) {
+    lines.push("- No post types reported.");
+  }
+  if (summary.counts.warnings > 0) {
+    lines.push("", "## Warnings", "");
+    for (const [surface, warnings] of Object.entries(summary.warningsBySurface).sort()) {
+      for (const warning of warnings) {
+        lines.push(`- ${surface}: [${warning.code}] ${warning.message}`);
+      }
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function groupWarnings(warnings) {
+  const grouped = {};
+  for (const warning of warnings) {
+    grouped[warning.surface] ??= [];
+    grouped[warning.surface]?.push(warning);
+  }
+  return grouped;
+}
+
+// src/collector/wpcli.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var COLLECTOR_VERSION = "0.1.0";
+async function collectWpCli(options) {
+  if (!options.wpPath && !options.ssh) {
+    throw new Error("WP-CLI collector requires --wp-path or --ssh.");
+  }
+  const wpBinary = options.wpBinary ?? "wp";
+  const args = wpArgs(options, ["eval", PHP_COLLECTOR]);
+  const { stdout } = await execFileAsync(wpBinary, args, {
+    encoding: "utf8",
+    maxBuffer: 1024 * 1024 * 20
+  });
+  const raw = parseCollectorJson(stdout);
+  return normalizeCollectorOutput(raw);
+}
+function wpArgs(options, command) {
+  const args = [];
+  if (options.ssh) {
+    args.push(`--ssh=${options.ssh}`);
+  }
+  if (options.wpPath) {
+    args.push(`--path=${options.wpPath}`);
+  }
+  if (options.wpUrl) {
+    args.push(`--url=${options.wpUrl}`);
+  }
+  args.push(...command);
+  return args;
+}
+function parseCollectorJson(stdout) {
+  const trimmed = stdout.trim();
+  const start = trimmed.indexOf("{");
+  const end = trimmed.lastIndexOf("}");
+  if (start === -1 || end === -1 || end <= start) {
+    throw new Error("WP-CLI collector did not return JSON.");
+  }
+  return JSON.parse(trimmed.slice(start, end + 1));
+}
+function normalizeCollectorOutput(raw) {
+  const warnings = warningArray(raw.warnings);
+  const bindingsRaw = record(raw.bindings);
+  const themeRaw = record(raw.theme);
+  const settings = themeRaw.settings;
+  warnings.push(...themeWarnings(settings));
+  const contextWithoutHash = redactSecrets({
+    $schema: SCHEMA_URL,
+    contextVersion: CONTEXT_VERSION,
+    site: record(raw.site),
+    provenance: {
+      collectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      collector: "wp-cli",
+      collectorVersion: COLLECTOR_VERSION,
+      sourceHash: "sha256:0000000000000000000000000000000000000000000000000000000000000000",
+      partial: warnings.some((warning) => warning.severity !== "info")
+    },
+    wordpress: record(raw.wordpress),
+    theme: {
+      ...themeRaw,
+      settingsOrigin: "merged",
+      themeJsonHash: settings ? sourceHash({ settings }) : void 0,
+      tokens: parseThemeJsonSettings(settings),
+      settings
+    },
+    plugins: array(raw.plugins),
+    blocks: {
+      types: sortByName(array(record(raw.blocks).types))
+    },
+    bindings: {
+      available: Boolean(bindingsRaw.available),
+      sources: sortByName(array(bindingsRaw.sources)),
+      supportedAttributes: sortSupportedAttributes(record(bindingsRaw.supportedAttributes)),
+      warnings: warningArray(bindingsRaw.warnings)
+    },
+    contentModel: {
+      postTypes: sortPostTypes(array(record(raw.contentModel).postTypes))
+    },
+    patterns: {
+      items: sortByName(array(record(raw.patterns).items))
+    },
+    media: record(raw.media),
+    warnings
+  });
+  const context = {
+    ...contextWithoutHash,
+    provenance: {
+      ...contextWithoutHash.provenance,
+      sourceHash: sourceHash(contextWithoutHash)
+    }
+  };
+  return siteContextSchema.parse(context);
+}
+function warningArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((warning) => {
+    return Boolean(
+      warning && typeof warning === "object" && typeof warning.code === "string" && typeof warning.severity === "string" && typeof warning.message === "string" && typeof warning.surface === "string"
+    );
+  });
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function array(value) {
+  return Array.isArray(value) ? value.filter((item) => item && typeof item === "object") : [];
+}
+function sortByName(items) {
+  return [...items].sort((left, right) => String(left.name ?? "").localeCompare(String(right.name ?? "")));
+}
+function sortPostTypes(items) {
+  return sortByName(items).map((postType) => ({
+    ...postType,
+    fields: sortByName(array(postType.fields)),
+    taxonomies: Array.isArray(postType.taxonomies) ? [...postType.taxonomies].sort() : []
+  }));
+}
+function sortSupportedAttributes(value) {
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([blockName, attributes]) => [
+      blockName,
+      Array.isArray(attributes) ? attributes.map(String).sort() : []
+    ])
+  );
+}
+var PHP_COLLECTOR = String.raw`
+$warnings = array();
+
+function wesper_warning($code, $surface, $message, $severity = 'warning') {
+    return array(
+        'code' => $code,
+        'severity' => $severity,
+        'surface' => $surface,
+        'message' => $message,
+    );
+}
+
+function wesper_public_props($object, $props) {
+    $out = array();
+    foreach ($props as $from => $to) {
+        if (is_int($from)) {
+            $from = $to;
+        }
+        if (is_object($object) && isset($object->{$from})) {
+            $out[$to] = $object->{$from};
+        } elseif (is_array($object) && array_key_exists($from, $object)) {
+            $out[$to] = $object[$from];
+        }
+    }
+    return $out;
+}
+
+global $wp_version;
+
+$theme = wp_get_theme();
+$settings = function_exists('wp_get_global_settings') ? wp_get_global_settings() : array();
+
+$plugins = array();
+if (!function_exists('get_plugin_data')) {
+    require_once ABSPATH . 'wp-admin/includes/plugin.php';
+}
+$active_plugins = (array) get_option('active_plugins', array());
+$network_plugins = is_multisite() ? array_keys((array) get_site_option('active_sitewide_plugins', array())) : array();
+foreach (array_values(array_unique(array_merge($active_plugins, $network_plugins))) as $plugin_file) {
+    $plugin_path = WP_PLUGIN_DIR . '/' . $plugin_file;
+    $data = file_exists($plugin_path) ? get_plugin_data($plugin_path, false, false) : array();
+    $plugins[] = array(
+        'slug' => $plugin_file,
+        'name' => isset($data['Name']) && $data['Name'] ? $data['Name'] : $plugin_file,
+        'version' => isset($data['Version']) ? $data['Version'] : '',
+        'active' => in_array($plugin_file, $active_plugins, true),
+        'networkActive' => in_array($plugin_file, $network_plugins, true),
+    );
+}
+
+$block_types = array();
+foreach (WP_Block_Type_Registry::get_instance()->get_all_registered() as $name => $block_type) {
+    $block_types[] = array(
+        'name' => $name,
+        'apiVersion' => isset($block_type->api_version) ? $block_type->api_version : null,
+        'title' => isset($block_type->title) ? $block_type->title : null,
+        'category' => isset($block_type->category) ? $block_type->category : null,
+        'attributes' => isset($block_type->attributes) ? $block_type->attributes : array(),
+        'supports' => isset($block_type->supports) ? $block_type->supports : array(),
+        'source' => strpos($name, 'core/') === 0 ? 'core' : 'plugin',
+    );
+}
+
+$binding_sources = array();
+$bindings_available = function_exists('get_all_registered_block_bindings_sources');
+if ($bindings_available) {
+    foreach (get_all_registered_block_bindings_sources() as $name => $source) {
+        $binding_sources[] = array(
+            'name' => $name,
+            'label' => isset($source->label) ? $source->label : null,
+            'usesContext' => isset($source->uses_context) ? array_values((array) $source->uses_context) : array(),
+            'argsSchema' => null,
+        );
+    }
+} else {
+    $warnings[] = wesper_warning('bindings.unavailable', 'bindings', 'Block Bindings are unavailable before WordPress 6.5.');
+}
+
+$core_supported_attributes = array(
+    'core/paragraph' => array('content'),
+    'core/heading' => array('content'),
+    'core/image' => array('id', 'url', 'title', 'alt', 'caption'),
+    'core/button' => array('url', 'text', 'linkTarget', 'rel'),
+    'core/post-date' => array('datetime'),
+    'core/navigation-link' => array('url'),
+    'core/navigation-submenu' => array('url'),
+);
+$supported_attributes = array();
+if (function_exists('get_block_bindings_supported_attributes')) {
+    foreach ($block_types as $block_type) {
+        $attrs = get_block_bindings_supported_attributes($block_type['name']);
+        if (!empty($attrs)) {
+            $supported_attributes[$block_type['name']] = array_values($attrs);
+        }
+    }
+} else {
+    $supported_attributes = $core_supported_attributes;
+    $warnings[] = wesper_warning('bindings.supported_attributes_partial', 'bindings.supportedAttributes', 'WordPress does not expose get_block_bindings_supported_attributes(); using documented core compatibility table.');
+}
+
+$post_types = array();
+foreach (get_post_types(array(), 'objects') as $post_type_name => $post_type_object) {
+    $fields = array(
+        array('key' => 'title', 'source' => 'core/post-data', 'type' => 'string', 'bindable' => true),
+        array('key' => 'excerpt', 'source' => 'core/post-data', 'type' => 'string', 'bindable' => true),
+        array('key' => 'featured_media', 'source' => 'core/post-data', 'type' => 'integer', 'bindable' => true),
+    );
+    $registered_meta = function_exists('get_registered_meta_keys') ? get_registered_meta_keys('post', $post_type_name) : array();
+    foreach ($registered_meta as $meta_key => $args) {
+        $show_in_rest = !empty($args['show_in_rest']);
+        $protected = isset($args['protected']) ? (bool) $args['protected'] : strpos((string) $meta_key, '_') === 0;
+        if (!$show_in_rest || $protected) {
+            continue;
+        }
+        $fields[] = array(
+            'key' => (string) $meta_key,
+            'source' => 'core/post-meta',
+            'type' => isset($args['type']) ? (string) $args['type'] : 'string',
+            'single' => isset($args['single']) ? (bool) $args['single'] : false,
+            'showInRest' => true,
+            'bindable' => true,
+        );
+    }
+    if (empty($registered_meta)) {
+        $warnings[] = wesper_warning('content_model.no_registered_meta', 'contentModel.postTypes.' . $post_type_name . '.fields', 'No registered REST-visible meta was discovered for this post type.', 'info');
+    }
+    $post_types[] = array(
+        'name' => $post_type_name,
+        'label' => $post_type_object->label,
+        'public' => (bool) $post_type_object->public,
+        'showInRest' => (bool) $post_type_object->show_in_rest,
+        'taxonomies' => array_values(get_object_taxonomies($post_type_name)),
+        'fields' => $fields,
+    );
+}
+
+$patterns = array();
+if (class_exists('WP_Block_Patterns_Registry')) {
+    foreach (WP_Block_Patterns_Registry::get_instance()->get_all_registered() as $name => $pattern) {
+        $patterns[] = array(
+            'name' => $name,
+            'title' => isset($pattern['title']) ? $pattern['title'] : null,
+            'categories' => isset($pattern['categories']) ? array_values((array) $pattern['categories']) : array(),
+            'blockTypes' => isset($pattern['blockTypes']) ? array_values((array) $pattern['blockTypes']) : array(),
+            'postTypes' => isset($pattern['postTypes']) ? array_values((array) $pattern['postTypes']) : array(),
+        );
+    }
+}
+
+$output = array(
+    'site' => array(
+        'url' => get_bloginfo('url'),
+        'name' => get_bloginfo('name'),
+        'environment' => function_exists('wp_get_environment_type') ? wp_get_environment_type() : 'unknown',
+        'isMultisite' => is_multisite(),
+    ),
+    'wordpress' => array(
+        'version' => $wp_version,
+        'locale' => get_locale(),
+        'permalinkStructure' => (string) get_option('permalink_structure'),
+        'features' => array(
+            'blockBindings' => $bindings_available,
+            'blockBindingsSupportedAttributesApi' => function_exists('get_block_bindings_supported_attributes'),
+            'patterns' => class_exists('WP_Block_Patterns_Registry'),
+        ),
+    ),
+    'theme' => array(
+        'stylesheet' => $theme->get_stylesheet(),
+        'template' => $theme->get_template(),
+        'name' => (string) $theme->get('Name'),
+        'version' => (string) $theme->get('Version'),
+        'isBlockTheme' => function_exists('wp_is_block_theme') ? wp_is_block_theme() : false,
+        'settings' => $settings,
+    ),
+    'plugins' => $plugins,
+    'blocks' => array('types' => $block_types),
+    'bindings' => array(
+        'available' => $bindings_available,
+        'sources' => $binding_sources,
+        'supportedAttributes' => $supported_attributes,
+        'warnings' => array(),
+    ),
+    'contentModel' => array('postTypes' => $post_types),
+    'patterns' => array('items' => $patterns),
+    'media' => array(
+        'imageSizes' => function_exists('wp_get_registered_image_subsizes') ? array_values(array_map(function($name, $size) {
+            return array(
+                'name' => $name,
+                'width' => isset($size['width']) ? $size['width'] : 0,
+                'height' => isset($size['height']) ? $size['height'] : 0,
+                'crop' => isset($size['crop']) ? (bool) $size['crop'] : false,
+            );
+        }, array_keys(wp_get_registered_image_subsizes()), wp_get_registered_image_subsizes())) : array(),
+        'maxUploadSize' => function_exists('wp_max_upload_size') ? wp_max_upload_size() : null,
+    ),
+    'warnings' => $warnings,
+);
+
+echo wp_json_encode($output);
+`;
+
+// src/index.ts
+async function collect(options) {
+  const collector = options.collector ?? "wp-cli";
+  switch (collector) {
+    case "wp-cli":
+      return enforceStrict(await collectWpCli({ ...options, collector }), options);
+    case "fixture":
+      throw new Error("Fixture collection is represented by validate() on a manifest file.");
+    default:
+      throw new Error(`Unsupported collector: ${String(collector)}`);
+  }
+}
+function validate(manifest) {
+  const redacted = redactSecrets(manifest);
+  const result = siteContextSchema.safeParse(redacted);
+  if (!result.success) {
+    return {
+      ok: false,
+      errors: issuesFromZod(result.error),
+      warnings: []
+    };
+  }
+  return {
+    ok: true,
+    context: result.data,
+    errors: [],
+    warnings: allWarnings(result.data)
+  };
+}
+function enforceStrict(context, options) {
+  const warnings = actionableWarnings(allWarnings(context));
+  if (options.strict && (context.provenance.partial || warnings.length > 0)) {
+    const surfaces = warnings.map((warning) => warning.surface).join(", ") || "provenance.partial";
+    throw new Error(`Strict collection failed because the manifest is partial or has actionable warnings: ${surfaces}`);
+  }
+  return context;
+}
+function issuesFromZod(error) {
+  return error.issues.map((issue) => ({
+    path: issue.path.join("."),
+    message: issue.message
+  }));
+}
+
+export {
+  CONTEXT_VERSION,
+  SCHEMA_URL,
+  siteContextSchema,
+  siteContextJsonSchema,
+  redactSecrets,
+  canonicalize,
+  sourceHash,
+  parseThemeJsonSettings,
+  allWarnings,
+  hasActionableWarnings,
+  summarize,
+  formatSummaryMarkdown,
+  collect,
+  validate
+};