@withstudiocms/component-registry 0.1.0-beta.5 → 0.1.0-beta.7

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @withstudiocms/component-registry
 
+## 0.1.0-beta.7
+
+### Patch Changes
+
+- [#1029](https://github.com/withstudiocms/studiocms/pull/1029) [`da369c7`](https://github.com/withstudiocms/studiocms/commit/da369c7bd8f40670cb56821d74686c79840f06e4) Thanks [@Adammatthiesen](https://github.com/Adammatthiesen)! - Integrates new Kysely based SDK into StudioCMS
+
+- Updated dependencies [[`ee90810`](https://github.com/withstudiocms/studiocms/commit/ee9081053f808d4366a9c95e13539a5198b27bb5), [`a5b84c5`](https://github.com/withstudiocms/studiocms/commit/a5b84c52383bf299aa70c04b064850c7883b59b1), [`9a8bfed`](https://github.com/withstudiocms/studiocms/commit/9a8bfeda461dbc7e3188222db3adeffca1c29f6a), [`ba79740`](https://github.com/withstudiocms/studiocms/commit/ba797403563b8fbd381e0fc28f4ccba0ec6432a6), [`3c54788`](https://github.com/withstudiocms/studiocms/commit/3c54788df0bd548f1e3489b7c7334279ee85d5cb), [`1e1e6a1`](https://github.com/withstudiocms/studiocms/commit/1e1e6a1038de31bfe73070b4feb7163a3e7385a0), [`97c7847`](https://github.com/withstudiocms/studiocms/commit/97c7847c0cdd41998e0a6d8c61ab6f3c4ac4474e), [`675b7d5`](https://github.com/withstudiocms/studiocms/commit/675b7d5bbb2c40e6a204d3c7227812923e37289f)]:
+  - @withstudiocms/effect@0.1.0-beta.7
+
+## 0.1.0-beta.6
+
+### Patch Changes
+
+- [#978](https://github.com/withstudiocms/studiocms/pull/978) [`34e2c50`](https://github.com/withstudiocms/studiocms/commit/34e2c509914596d5e8bb75bceb6bf2b2cadeba3d) Thanks [@Adammatthiesen](https://github.com/Adammatthiesen)! - Cleans up component registry code
+
+- Updated dependencies [[`61091e1`](https://github.com/withstudiocms/studiocms/commit/61091e1e7633f1b4bf0fa3e0a09debb06b861fbe)]:
+  - @withstudiocms/effect@0.1.0-beta.6
+
 ## 0.1.0-beta.5
 
 ### Patch Changes

package/dist/registry/PropsParser.js

@@ -143,7 +143,7 @@ class PropsParser extends Effect.Service()("PropsParser", {
         try: () => {
           const frontmatterMatch = astroFileContent.match(/^---\s*\n([\s\S]*?)\n---/m);
           if (!frontmatterMatch) {
-            throw new Error("No frontmatter found in Astro file");
+            return "";
           }
           const frontmatter = frontmatterMatch[1];
           const interfaceMatch = frontmatter.match(
@@ -164,7 +164,7 @@ class PropsParser extends Effect.Service()("PropsParser", {
             /(?:export\s+)?(?:interface|type)\s+Props\s*[={]/
           );
           if (propsStart === -1) {
-            throw new Error("No Props interface or type found in frontmatter");
+            return "";
           }
           const propsSubstring = frontmatter.substring(propsStart);
           let braceCount = 0;

package/dist/registry/Registry.d.ts

@@ -1,11 +1,11 @@
 import { Effect, Layer, Platform } from '@withstudiocms/effect';
-import { ComponentNotFoundError, ComponentRegistryError, FileParseError } from '../errors.js';
+import { ComponentNotFoundError } from '../errors.js';
 import type { AstroComponentProps } from '../types.js';
 import { PropsParser } from './PropsParser.js';
 declare const ComponentRegistry_base: Effect.Service.Class<ComponentRegistry, "ComponentRegistry", {
     readonly dependencies: readonly [Layer.Layer<PropsParser, never, never>, Layer.Layer<Platform.Path.Path, never, never>, Layer.Layer<Platform.FileSystem.FileSystem, never, never>];
     readonly effect: Effect.Effect<{
-        registerComponentFromFile: (filePath: string, componentName?: string) => Effect.Effect<void, ComponentRegistryError | FileParseError | Platform.Error.PlatformError, never>;
+        registerComponentFromFile: (filePath: string, componentName?: string | undefined) => Effect.Effect<void, import("../errors.js").ComponentRegistryError | import("../errors.js").FileParseError | Platform.Error.PlatformError, never>;
         getAllComponents: () => Effect.Effect<Map<string, AstroComponentProps>, never, never>;
         getComponentProps: (componentName: string) => Effect.Effect<AstroComponentProps, ComponentNotFoundError, never>;
         validateProps: (componentName: string, props: Record<string, unknown>) => Effect.Effect<{

package/dist/registry/Registry.js

@@ -1,5 +1,5 @@
 import { Effect, Layer, Platform, PlatformNode } from "@withstudiocms/effect";
-import { ComponentNotFoundError, ComponentRegistryError, FileParseError } from "../errors.js";
+import { ComponentNotFoundError } from "../errors.js";
 import { PropsParser } from "./PropsParser.js";
 const registryDeps = Layer.mergeAll(
   PropsParser.Default,
@@ -9,69 +9,56 @@ const registryDeps = Layer.mergeAll(
 class ComponentRegistry extends Effect.Service()("ComponentRegistry", {
   dependencies: [PropsParser.Default, Platform.Path.layer, PlatformNode.NodeFileSystem.layer],
   effect: Effect.gen(function* () {
-    const parser = yield* PropsParser;
-    const fs = yield* Platform.FileSystem.FileSystem;
-    const path = yield* Platform.Path.Path;
+    const [parser, fs, path] = yield* Effect.all([
+      PropsParser,
+      Platform.FileSystem.FileSystem,
+      Platform.Path.Path
+    ]);
     const components = /* @__PURE__ */ new Map();
-    return {
-      registerComponentFromFile: (filePath, componentName) => Effect.gen(function* () {
-        const fileContent = yield* fs.readFileString(filePath);
-        const propsDefinition = yield* parser.extractPropsFromAstroFile(fileContent).pipe(
-          Effect.mapError(
-            (error) => new FileParseError({
-              filePath,
-              message: error.message,
-              cause: error.cause
-            })
-          )
-        );
-        const name = componentName || path.basename(filePath, path.extname(filePath));
-        const parsed = yield* parser.parseComponentProps(propsDefinition).pipe(
-          Effect.mapError(
-            (error) => (
-              /* v8 ignore start */
-              new ComponentRegistryError({
-                message: `Failed to register component ${name}`,
-                cause: error
-              })
-            )
-            /* v8 ignore stop */
-          )
-        );
-        if (parsed.length > 0) {
-          components.set(name, parsed[0]);
-        }
-      }),
-      getAllComponents: () => Effect.succeed(new Map(components)),
-      getComponentProps: (componentName) => Effect.gen(function* () {
-        const component = components.get(componentName);
-        if (!component) {
-          return yield* Effect.fail(new ComponentNotFoundError({ componentName }));
+    const _registerComponentFromFile = Effect.fn(
+      (filePath, componentName) => fs.readFileString(filePath).pipe(
+        Effect.flatMap(parser.extractPropsFromAstroFile),
+        Effect.flatMap(parser.parseComponentProps),
+        Effect.map((parsed) => {
+          const name = componentName || path.basename(filePath, path.extname(filePath));
+          const component = parsed[0] ?? {
+            name,
+            props: []
+          };
+          components.set(name, component);
+        })
+      )
+    );
+    const _getAllComponents = Effect.fn(() => Effect.succeed(new Map(components)));
+    const _getComponentProps = Effect.fn(function* (componentName) {
+      const component = components.get(componentName);
+      if (!component) {
+        return yield* Effect.fail(new ComponentNotFoundError({ componentName }));
+      }
+      return component;
+    });
+    const _validateProps = Effect.fn(function* (componentName, props) {
+      const component = yield* _getComponentProps(componentName);
+      const errors = [];
+      const providedProps = new Set(Object.keys(props));
+      for (const prop of component.props) {
+        if (!prop.optional && !providedProps.has(prop.name)) {
+          errors.push(`Required prop "${prop.name}" is missing`);
         }
-        return component;
-      }),
-      validateProps: (componentName, props) => Effect.gen(function* () {
-        const component = components.get(componentName);
-        if (!component) {
-          return yield* Effect.fail(new ComponentNotFoundError({ componentName }));
+      }
+      const validPropNames = new Set(component.props.map((p) => p.name));
+      for (const propName of providedProps) {
+        if (!validPropNames.has(propName)) {
+          errors.push(`Unknown prop "${propName}"`);
         }
-        const errors = [];
-        const providedProps = new Set(Object.keys(props));
-        if (component) {
-          for (const prop of component.props) {
-            if (!prop.optional && !providedProps.has(prop.name)) {
-              errors.push(`Required prop "${prop.name}" is missing`);
-            }
-          }
-          const validPropNames = new Set(component.props.map((p) => p.name));
-          for (const propName of providedProps) {
-            if (!validPropNames.has(propName)) {
-              errors.push(`Unknown prop "${propName}"`);
-            }
-          }
-        }
-        return { valid: errors.length === 0, errors };
-      })
+      }
+      return { valid: errors.length === 0, errors };
+    });
+    return {
+      registerComponentFromFile: _registerComponentFromFile,
+      getAllComponents: _getAllComponents,
+      getComponentProps: _getComponentProps,
+      validateProps: _validateProps
     };
   }).pipe(Effect.provide(registryDeps))
 }) {

package/dist/registry/handler.d.ts

@@ -1,106 +1,113 @@
 /// <reference types="../virtual.d.ts" preserve="true" />
-import { Effect } from '@withstudiocms/effect';
-import { z } from 'astro/zod';
-export declare const ComponentRegistryHandlerOptionSchema: z.ZodObject<{
-    config: z.ZodObject<{
-        /**
-         * The name of the integration
-         */
-        name: z.ZodString;
-        /**
-         * The virtual module ID for generated imports
-         *
-         * @example 'virtual:my-integration'
-         */
-        virtualId: z.ZodOptional<z.ZodString>;
-        /**
-         * Enables verbose logging
-         */
-        verbose: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-    }, "strip", z.ZodTypeAny, {
-        name: string;
-        verbose?: boolean | undefined;
-        virtualId?: string | undefined;
-    }, {
-        name: string;
-        verbose?: boolean | undefined;
-        virtualId?: string | undefined;
+import { Schema } from '@withstudiocms/effect';
+/**
+ * Schema for validating options passed to the component registry.
+ *
+ * @remarks
+ * This schema enforces the shape of the options object used to configure the
+ * component registry. It expects a required top-level `config` object and two
+ * optional record maps (`componentRegistry` and `builtInComponents`) keyed by
+ * string. The schema is intended to be used with the project's `Schema` utility
+ * to validate runtime inputs.
+ *
+ * @property config - Required configuration object for the registry.
+ * @property config.name - The required name of the registry instance (string).
+ * @property config.virtualId - Optional virtual identifier used for lookup or
+ *   resolution (string).
+ * @property config.verbose - Optional flag to enable verbose logging or
+ *   diagnostics (boolean).
+ * @property componentRegistry - Optional string-keyed record describing
+ *   externally provided components or component entries. The exact shape of
+ *   each record value is defined by `StringRecordSchema` in the codebase.
+ * @property builtInComponents - Optional string-keyed record describing
+ *   built-in components provided by the system. Also uses `StringRecordSchema`.
+ *
+ * @example
+ * // Example shape that conforms to this schema:
+ * // {
+ * //   config: { name: "my-registry", virtualId: "v1", verbose: true },
+ * //   componentRegistry: { "button": "/components/button" },
+ * //   builtInComponents: { "text": "/components/text" }
+ * // }
+ */
+export declare const ComponentRegistryOptionsSchema: Schema.Struct<{
+    config: Schema.Struct<{
+        name: typeof Schema.String;
+        virtualId: Schema.optional<typeof Schema.String>;
+        verbose: Schema.optional<typeof Schema.Boolean>;
     }>;
-    /**
-     * A record of user-provided component names to file paths.
-     */
-    componentRegistry: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    /**
-     * A record of built-in component names to file paths.
-     */
-    builtInComponents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-}, "strip", z.ZodTypeAny, {
-    config: {
-        name: string;
-        verbose?: boolean | undefined;
-        virtualId?: string | undefined;
-    };
-    componentRegistry?: Record<string, string> | undefined;
-    builtInComponents?: Record<string, string> | undefined;
-}, {
-    config: {
-        name: string;
-        verbose?: boolean | undefined;
-        virtualId?: string | undefined;
-    };
-    componentRegistry?: Record<string, string> | undefined;
-    builtInComponents?: Record<string, string> | undefined;
+    componentRegistry: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+    builtInComponents: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
 }>;
-export type ComponentRegistryHandlerOptions = z.infer<typeof ComponentRegistryHandlerOptionSchema>;
 /**
- * Creates an Effect-based resolver function for resolving component paths.
+ * Represents the TypeScript type inferred from the runtime schema that defines options for the component registry.
  *
- * @param base - The base path used to initialize the resolver.
- * @returns An Effect-wrapped function that accepts a callback. The callback receives a `resolve` function,
- * which can be used to resolve component paths relative to the base. If an error occurs during resolution,
- * it is caught, logged to the console, and an Error object is returned with the original error as its cause.
+ * This alias is produced by applying the schema-to-type helper (Schema.Schema.Type) to the schema that describes
+ * the registry options. Use this type when declaring or validating objects that will be passed to the component
+ * registry to ensure compile-time alignment with the runtime schema.
  *
- * @example
- * const resolveEffect = resolver('/components');
- * const result = yield* resolveEffect((resolve) => resolve('Button'));
+ * Notes:
+ * - The precise shape, allowed properties, and defaults are determined by the underlying schema; consult that
+ *   schema for the authoritative specification of each option.
+ * - Because this type is derived from the schema, updating the schema will automatically update this type.
  */
-export declare const resolver: (base: string) => Effect.Effect<(fn: (resolve: (...path: Array<string>) => string) => string) => Effect.Effect<string, Error, never>, never, never>;
+export type ComponentRegistryOptions = Schema.Schema.Type<typeof ComponentRegistryOptionsSchema>;
 /**
- * Handles the setup and registration of components in the component registry during the Astro config setup phase.
+ * Handler for the "astro:config:setup" utility that configures and populates the component registry for an Astro integration.
  *
- * This utility merges built-in and user-provided component registries, validates and resolves component paths,
- * registers components, and generates virtual imports for use at runtime. It also logs detailed information
- * about the registration process, including the number of components processed and their properties.
+ * This handler:
+ * - Decodes and validates the provided options using the ComponentRegistryOptionsSchema.
+ * - Forks and configures a logger scoped to the integration name, supporting a verbose mode for more detailed output.
+ * - Merges built-in components with user-provided component registry entries.
+ * - Iterates the merged registry and validates each entry:
+ *   - Only string paths ending with ".astro" are considered.
+ *   - Each component path is resolved via Astro's resolver; failures are logged and the entry is skipped.
+ * - Registers successfully resolved components with the ComponentRegistry effect and collects component metadata (props).
+ * - Constructs virtual imports for:
+ *   - A generated component index (exports for each detected component).
+ *   - A name export for the integration.
+ *   - A runtime module import.
+ *   - Optional alias exports when `virtualId` is provided.
+ * - Adds the virtual imports to Astro's config so they are available at runtime.
+ * - Emits informative log messages throughout; when `verbose` is true and there are few components, it logs the extracted component props in full.
  *
  * @remarks
- * - Only components with string values ending in `.astro` are considered valid.
- * - Uses Effect for error handling and asynchronous operations.
- * - Generates virtual modules for internal proxying and runtime usage.
+ * - The handler operates within the Effect runtime and uses an injected ComponentRegistry implementation (ComponentRegistry.Default by default).
+ * - Path resolution and registry interactions are handled as Effects; resolution errors are caught and logged so processing continues for other entries.
+ * - The handler gracefully skips invalid, non-".astro", or unresolved component entries instead of failing fast.
+ *
+ * @param params - The Astro config setup parameters provided by defineUtility('astro:config:setup'). Contains the integration config, root path, logger, and other environment helpers used for resolving and registering components.
+ * @param opts - Options validated against ComponentRegistryOptionsSchema. Typical fields include:
+ *   - name: string — name of the integration (used for log scoping and virtual exports).
+ *   - verbose?: boolean — enable verbose logging.
+ *   - virtualId?: string — optional virtual alias identifier to emit alias exports.
+ *   - builtInComponents?: Record<string, string> — default components provided by the integration.
+ *   - componentRegistry?: Record<string, string> — user-provided component mapping.
+ *
+ * @returns An Effect-wrapped completion of the setup process. When executed, the effect configures the ComponentRegistry, registers components, and installs virtual imports into the Astro configuration. Any non-fatal errors encountered during resolution or registration are logged and cause the individual entry to be skipped; unrecoverable errors will surface as Effect failures.
  *
- * @param params - The parameters provided by the Astro utility hook, including logger and config.
- * @param options - An object containing configuration and registry options:
- *   - `config.verbose` - Enables verbose logging if true.
- *   - `config.name` - The name of the integration for logging purposes.
- *   - `config.virtualId` - The virtual module ID for generated imports.
- *   - `builtInComponents` - A record of built-in component names to file paths.
- *   - `componentRegistry` - A record of user-provided component names to file paths.
- * @returns A promise that resolves after the component registry has been set up and virtual imports have been added.
+ * @throws Resolution or registry errors are handled per-entry and logged; fatal errors related to effect provisioning or unexpected failures may be thrown as Effect failures.
  *
  * @example
- * ```typescript
- * await componentRegistryHandler(params, {
- *   config: { verbose: true, name: 'my-integration', virtualId: 'virtual:my-registry' },
- *   builtInComponents: { button: '/components/Button.astro' },
- *   componentRegistry: { card: '/components/Card.astro' }
- * });
- * ```
+ * // Conceptual usage (options shape)
+ * // {
+ * //   name: 'my-integration',
+ * //   verbose: true,
+ * //   virtualId: 'virtual:components',
+ * //   builtInComponents: { Header: './components/Header.astro' },
+ * //   componentRegistry: { Footer: './src/components/Footer.astro' }
+ * // }
  */
-export declare const componentRegistryHandler: import("astro-integration-kit").HookUtility<"astro:config:setup", [{
-    config: {
-        name: string;
-        verbose?: boolean | undefined;
-        virtualId?: string | undefined;
+export declare const componentRegistryHandler: import("astro-integration-kit").HookUtility<"astro:config:setup", [opts: {
+    readonly config: {
+        readonly verbose?: boolean | undefined;
+        readonly name: string;
+        readonly virtualId?: string | undefined;
     };
-    componentRegistry?: Record<string, string> | undefined;
-    builtInComponents?: Record<string, string> | undefined;
+    readonly componentRegistry?: {
+        readonly [x: string]: string;
+    } | undefined;
+    readonly builtInComponents?: {
+        readonly [x: string]: string;
+    } | undefined;
 }], Promise<void>>;

package/dist/registry/handler.js

@@ -1,7 +1,6 @@
-import { deepmerge, Effect, runEffect } from "@withstudiocms/effect";
-import { z } from "astro/zod";
-import { addVirtualImports, createResolver, defineUtility } from "astro-integration-kit";
-import { convertHyphensToUnderscores, integrationLogger } from "../utils.js";
+import { deepmerge, Effect, runEffect, Schema } from "@withstudiocms/effect";
+import { addVirtualImports, defineUtility } from "astro-integration-kit";
+import { convertHyphensToUnderscores, integrationLogger, resolver } from "../utils.js";
 import {
   buildAliasExports,
   buildVirtualImport,
@@ -10,51 +9,24 @@ import {
   RuntimeInternalId
 } from "./consts.js";
 import { ComponentRegistry } from "./Registry.js";
-const ComponentRegistryHandlerOptionSchema = z.object({
-  config: z.object({
-    /**
-     * The name of the integration
-     */
-    name: z.string(),
-    /**
-     * The virtual module ID for generated imports
-     *
-     * @example 'virtual:my-integration'
-     */
-    virtualId: z.string().optional(),
-    /**
-     * Enables verbose logging
-     */
-    verbose: z.boolean().default(false).optional()
+const StringRecordSchema = Schema.Record({ key: Schema.String, value: Schema.String });
+const ComponentRegistryOptionsSchema = Schema.Struct({
+  config: Schema.Struct({
+    name: Schema.String,
+    virtualId: Schema.optional(Schema.String),
+    verbose: Schema.optional(Schema.Boolean)
   }),
-  /**
-   * A record of user-provided component names to file paths.
-   */
-  componentRegistry: z.record(z.string(), z.string()).optional(),
-  /**
-   * A record of built-in component names to file paths.
-   */
-  builtInComponents: z.record(z.string(), z.string()).optional()
-});
-const resolver = Effect.fn(function* (base) {
-  const { resolve: _resolve } = createResolver(base);
-  return Effect.fn(
-    (fn) => Effect.try({
-      try: () => fn(_resolve),
-      catch: (error) => {
-        console.error("Error occurred while resolving component:", error);
-        return new Error("Failed to resolve component", { cause: error });
-      }
-    })
-  );
+  componentRegistry: Schema.optional(StringRecordSchema),
+  builtInComponents: Schema.optional(StringRecordSchema)
 });
 const componentRegistryHandler = defineUtility("astro:config:setup")(
-  async (params, {
-    config: { verbose = false, name, virtualId },
-    builtInComponents = {},
-    componentRegistry = {}
-  }) => await runEffect(
+  async (params, opts) => await runEffect(
     Effect.gen(function* () {
+      const {
+        config: { verbose = false, name, virtualId },
+        builtInComponents = {},
+        componentRegistry = {}
+      } = yield* Schema.decode(ComponentRegistryOptionsSchema)(opts);
       const logger = params.logger.fork(`${name}:component-registry`);
       const logInfo = { logger, logLevel: "info", verbose };
       integrationLogger(logInfo, "Setting up component registry...");
@@ -156,7 +128,6 @@ ${JSON.stringify(componentProps, null, 2)}`
   )
 );
 export {
-  ComponentRegistryHandlerOptionSchema,
-  componentRegistryHandler,
-  resolver
+  ComponentRegistryOptionsSchema,
+  componentRegistryHandler
 };

package/dist/utils.d.ts

@@ -1,3 +1,4 @@
+import { Effect } from '@withstudiocms/effect';
 import type { AstroIntegrationLogger } from 'astro';
 /**
  * Options for configuring the logger.
@@ -50,3 +51,16 @@ export declare function getIndent(ln: string): string;
  * @returns The dedent string output.
  */
 export declare function dedent(str: string): string;
+/**
+ * Creates an Effect-based resolver function for resolving component paths.
+ *
+ * @param base - The base path used to initialize the resolver.
+ * @returns An Effect-wrapped function that accepts a callback. The callback receives a `resolve` function,
+ * which can be used to resolve component paths relative to the base. If an error occurs during resolution,
+ * it is caught, logged to the console, and an Error object is returned with the original error as its cause.
+ *
+ * @example
+ * const resolveEffect = resolver('/components');
+ * const result = yield* resolveEffect((resolve) => resolve('Button'));
+ */
+export declare const resolver: (base: string) => Effect.Effect<(fn: (resolve: (...path: Array<string>) => string) => string) => Effect.Effect<string, Error, never>, never, never>;

package/dist/utils.js

@@ -1,3 +1,5 @@
+import { Effect } from "@withstudiocms/effect";
+import { createResolver } from "astro-integration-kit";
 const integrationLogger = async (opts, message) => {
   const { logLevel, logger, verbose = false } = opts;
   switch (verbose) {
@@ -32,10 +34,23 @@ function dedent(str) {
   if (indent.length === 0) return lns.join("\n");
   return lns.map((ln) => ln.startsWith(indent) ? ln.slice(indent.length) : ln).join("\n");
 }
+const resolver = Effect.fn(function* (base) {
+  const { resolve: _resolve } = createResolver(base);
+  return Effect.fn(
+    (fn) => Effect.try({
+      try: () => fn(_resolve),
+      catch: (error) => {
+        console.error("Error occurred while resolving component:", error);
+        return new Error("Failed to resolve component", { cause: error });
+      }
+    })
+  );
+});
 export {
   convertHyphensToUnderscores,
   convertUnderscoresToHyphens,
   dedent,
   getIndent,
-  integrationLogger
+  integrationLogger,
+  resolver
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withstudiocms/component-registry",
-  "version": "0.1.0-beta.5",
+  "version": "0.1.0-beta.7",
   "description": "Component Registry Utilities for Astro",
   "license": "MIT",
   "author": {
@@ -72,7 +72,7 @@
     "astro-integration-kit": "^0.19.1",
     "ts-morph": "^27.0.2",
     "ultrahtml": "1.6.0",
-    "@withstudiocms/effect": "0.1.0-beta.5"
+    "@withstudiocms/effect": "0.1.0-beta.7"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",