@forgerock/login-framework-cli 0.0.0-beta-20260429204418

package/dist/src/config/exclusions.js

@@ -0,0 +1,62 @@
+const EXCLUDED_PREFIXES = [
+    '.git/',
+    '.github/',
+    '.changeset/',
+    '.claude/',
+    '.husky/',
+    '.vscode/',
+    '.playwright-mcp/',
+    '.svelte-kit/',
+    'node_modules/',
+    'storybook-static/',
+    'packages/login-widget/dist/',
+    'packages/login-widget/svelte-package/',
+    'packages/login-widget/node_modules/',
+    'apps/login-app/build/',
+    'apps/login-app/.svelte-kit/',
+    'apps/login-app/node_modules/',
+    'e2e/node_modules/',
+    'e2e/test-results/',
+    'e2e/playwright-report/',
+    'e2e/blob-report/',
+    'docs/',
+    'specs/',
+    'tools/',
+];
+const EXCLUDED_FILES = [
+    '.env',
+    '.mcp.json',
+    'pnpm-lock.yaml',
+    'package-lock.json',
+    'yarn.lock',
+    'CLAUDE.md',
+    '.generator-version',
+    'pnpm-workspace.yaml',
+    'tsconfig.json',
+    'bashrc',
+    'CONTRIBUTING.md',
+    'TESTING.md',
+    'seed.spec.ts',
+    'docker-compose.yml',
+    'Dockerfile',
+    'release.tar.gz',
+];
+const EXCLUDED_PATTERNS = [/^\.env\..*/, /\.d\.ts$/];
+const ALLOW_LIST = ['.env.example', '.env.docker.example'];
+import { normalizeSeparators } from '../utils.js';
+export function isExcluded(relativePath) {
+    const normalized = normalizeSeparators(relativePath);
+    if (ALLOW_LIST.some((allowed) => normalized === allowed)) {
+        return false;
+    }
+    if (EXCLUDED_FILES.some((file) => normalized === file)) {
+        return true;
+    }
+    if (EXCLUDED_PREFIXES.some((prefix) => `${normalized}/`.startsWith(prefix))) {
+        return true;
+    }
+    if (EXCLUDED_PATTERNS.some((pattern) => pattern.test(normalized))) {
+        return true;
+    }
+    return false;
+}

package/dist/src/config/version.d.ts

@@ -0,0 +1,26 @@
+import { Effect, Schema } from 'effect';
+import { FileSystem } from '@effect/platform';
+import { GeneratorVersionError } from '../errors.js';
+declare const GeneratorVersionSchema: Schema.Struct<{
+    version: typeof Schema.String;
+    commitHash: typeof Schema.String;
+    generatedAt: typeof Schema.String;
+}>;
+export type GeneratorVersion = typeof GeneratorVersionSchema.Type;
+export declare const readVersion: (directory: string) => Effect.Effect<{
+    readonly version: string;
+    readonly commitHash: string;
+    readonly generatedAt: string;
+}, GeneratorVersionError | import("@effect/platform/Error").PlatformError, FileSystem.FileSystem>;
+export declare const writeVersion: (directory: string, version: GeneratorVersion) => Effect.Effect<void, import("@effect/platform/Error").PlatformError, FileSystem.FileSystem>;
+/**
+ * Asserts the given directory is a valid ping-lf project root by checking
+ * for a well-formed `.generator-version` file. Fails with a user-facing
+ * error message when the check does not pass.
+ */
+export declare const assertValidProject: (directory: string) => Effect.Effect<{
+    readonly version: string;
+    readonly commitHash: string;
+    readonly generatedAt: string;
+}, GeneratorVersionError | import("@effect/platform/Error").PlatformError, FileSystem.FileSystem>;
+export {};

package/dist/src/config/version.js

@@ -0,0 +1,41 @@
+import { Console, Effect, Schema } from 'effect';
+import { FileSystem } from '@effect/platform';
+import { GeneratorVersionError } from '../errors.js';
+const GeneratorVersionSchema = Schema.Struct({
+    version: Schema.String,
+    commitHash: Schema.String,
+    generatedAt: Schema.String,
+});
+const VERSION_FILE = '.generator-version';
+const decodeGeneratorVersion = Schema.decodeUnknown(Schema.parseJson(GeneratorVersionSchema));
+const encodeGeneratorVersion = Schema.encode(Schema.parseJson(GeneratorVersionSchema));
+const parseGeneratorFromFile = (filePath) => FileSystem.FileSystem.pipe(Effect.flatMap((fs) => fs.readFileString(filePath)), Effect.flatMap(decodeGeneratorVersion), Effect.mapError(() => new GeneratorVersionError({
+    message: 'Malformed .generator-version file',
+    path: filePath,
+})));
+export const readVersion = (directory) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const filePath = `${directory}/${VERSION_FILE}`;
+    const exists = yield* fs.exists(filePath);
+    if (!exists) {
+        return yield* new GeneratorVersionError({
+            message: 'No .generator-version file found. Is this a generated project?',
+            path: filePath,
+        });
+    }
+    return yield* parseGeneratorFromFile(filePath);
+});
+export const writeVersion = (directory, version) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const filePath = `${directory}/${VERSION_FILE}`;
+    const encoded = yield* encodeGeneratorVersion(version).pipe(Effect.orDie);
+    yield* fs.writeFileString(filePath, encoded + '\n');
+});
+/**
+ * Asserts the given directory is a valid ping-lf project root by checking
+ * for a well-formed `.generator-version` file. Fails with a user-facing
+ * error message when the check does not pass.
+ */
+export const assertValidProject = (directory) => readVersion(directory).pipe(Effect.tapError((err) => Console.error(`\nError: ${err.message}\n` +
+    `  Make sure you are running this command from the root of an\n` +
+    `  initialized project (one created with "ping-lf init").\n`)));

package/dist/src/errors.d.ts

@@ -0,0 +1,90 @@
+declare const InvalidVersionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "InvalidVersionError";
+} & Readonly<A>;
+export declare class InvalidVersionError extends InvalidVersionError_base<{
+    readonly version: string;
+}> {
+}
+declare const ReleaseNetworkError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ReleaseNetworkError";
+} & Readonly<A>;
+export declare class ReleaseNetworkError extends ReleaseNetworkError_base<{
+    readonly cause: string;
+}> {
+}
+declare const ReleaseParseError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ReleaseParseError";
+} & Readonly<A>;
+export declare class ReleaseParseError extends ReleaseParseError_base<{
+    readonly cause: string;
+}> {
+}
+declare const ReleaseFsError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ReleaseFsError";
+} & Readonly<A>;
+export declare class ReleaseFsError extends ReleaseFsError_base<{
+    readonly operation: string;
+    readonly cause: string;
+}> {
+}
+declare const ReleaseNotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ReleaseNotFoundError";
+} & Readonly<A>;
+export declare class ReleaseNotFoundError extends ReleaseNotFoundError_base<{
+    readonly cause?: string;
+}> {
+}
+declare const FileSystemError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FileSystemError";
+} & Readonly<A>;
+export declare class FileSystemError extends FileSystemError_base<{
+    readonly operation: string;
+    readonly path: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const GeneratorVersionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "GeneratorVersionError";
+} & Readonly<A>;
+export declare class GeneratorVersionError extends GeneratorVersionError_base<{
+    readonly message: string;
+    readonly path?: string;
+}> {
+}
+declare const RegistryScanError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "RegistryScanError";
+} & Readonly<A>;
+export declare class RegistryScanError extends RegistryScanError_base<{
+    readonly directory: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const DirectoryConflictError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "DirectoryConflictError";
+} & Readonly<A>;
+export declare class DirectoryConflictError extends DirectoryConflictError_base<{
+    readonly path: string;
+}> {
+}
+declare const DirectoryNotEmptyError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "DirectoryNotEmptyError";
+} & Readonly<A>;
+export declare class DirectoryNotEmptyError extends DirectoryNotEmptyError_base<{
+    readonly path: string;
+}> {
+}
+declare const InvalidComponentNameError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "InvalidComponentNameError";
+} & Readonly<A>;
+export declare class InvalidComponentNameError extends InvalidComponentNameError_base<{
+    readonly name: string;
+}> {
+}
+declare const ComponentAlreadyExistsError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ComponentAlreadyExistsError";
+} & Readonly<A>;
+export declare class ComponentAlreadyExistsError extends ComponentAlreadyExistsError_base<{
+    readonly path: string;
+}> {
+}
+export {};

package/dist/src/errors.js

@@ -0,0 +1,25 @@
+import { Data } from 'effect';
+export class InvalidVersionError extends Data.TaggedError('InvalidVersionError') {
+}
+export class ReleaseNetworkError extends Data.TaggedError('ReleaseNetworkError') {
+}
+export class ReleaseParseError extends Data.TaggedError('ReleaseParseError') {
+}
+export class ReleaseFsError extends Data.TaggedError('ReleaseFsError') {
+}
+export class ReleaseNotFoundError extends Data.TaggedError('ReleaseNotFoundError') {
+}
+export class FileSystemError extends Data.TaggedError('FileSystemError') {
+}
+export class GeneratorVersionError extends Data.TaggedError('GeneratorVersionError') {
+}
+export class RegistryScanError extends Data.TaggedError('RegistryScanError') {
+}
+export class DirectoryConflictError extends Data.TaggedError('DirectoryConflictError') {
+}
+export class DirectoryNotEmptyError extends Data.TaggedError('DirectoryNotEmptyError') {
+}
+export class InvalidComponentNameError extends Data.TaggedError('InvalidComponentNameError') {
+}
+export class ComponentAlreadyExistsError extends Data.TaggedError('ComponentAlreadyExistsError') {
+}

package/dist/src/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/main.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { Command } from '@effect/cli';
+import { NodeContext, NodeRuntime } from '@effect/platform-node';
+import { Console, Effect } from 'effect';
+import { createRequire } from 'node:module';
+import { initCommand } from './commands/init.js';
+import { generateCommand } from './commands/generate.js';
+import { releasesCommand } from './commands/releases.js';
+import { updateCommand } from './commands/update.js';
+import { GithubReleaseLayer } from './services/release.js';
+// Read the version from package.json at runtime so it stays in sync
+// with the published package version after changesets bumps it.
+const { version } = createRequire(import.meta.url)('../package.json');
+const rootCommand = Command.make('ping-lf').pipe(Command.withDescription('CLI for initializing, scaffolding, and updating Ping Login Widget and Login App custom component projects.'), Command.withSubcommands([initCommand, generateCommand, updateCommand, releasesCommand]));
+const cli = Command.run(rootCommand, {
+    name: 'ping-lf',
+    version,
+});
+cli(process.argv).pipe(Effect.catchTag('DirectoryConflictError', (err) => Console.error(`\nError: "${err.path}" already contains a framework project.` +
+    `\n  Did you mean to use --local?\n` +
+    `\n    ping-lf init <new-directory> --local ${err.path}\n`).pipe(Effect.andThen(Effect.die(err)))), Effect.catchTag('DirectoryNotEmptyError', (err) => Console.error(`\nError: "${err.path}" already exists and is not empty.` +
+    `\n  Choose a different directory name, or delete the existing directory first.\n`).pipe(Effect.andThen(Effect.die(err)))), Effect.catchTag('ReleaseNetworkError', (err) => Console.error(`\nError: Could not reach GitHub to download the release.\n` +
+    `  ${err.cause}\n\n` +
+    `  • Check your network connection and try again.\n` +
+    `  • Use a local path:   ping-lf init <dir> --local <path>\n` +
+    `  • Specify a version:  ping-lf init <dir> --version v1.0.0\n`).pipe(Effect.andThen(Effect.die(err)))), Effect.catchTag('ReleaseParseError', (err) => Console.error(`\nError: Failed to parse the release data.\n  ${err.cause}\n`).pipe(Effect.andThen(Effect.die(err)))), Effect.catchTag('ReleaseFsError', (err) => Console.error(`\nError: Filesystem error during release download (${err.operation}).\n  ${err.cause}\n`).pipe(Effect.andThen(Effect.die(err)))), Effect.catchTag('InvalidVersionError', (err) => Console.error(`\nError: "${err.version}" is not a valid version tag.\n` +
+    `  Expected semver format like v1.0.0.\n` +
+    `  Use "ping-lf releases" to list available versions.\n`).pipe(Effect.andThen(Effect.die(err)))), Effect.catchTag('ReleaseNotFoundError', (err) => Console.error(`\nError: No releases found on GitHub.` +
+    (err.cause ? `\n  ${err.cause}` : '') +
+    `\n\n  • Check your network connection and try again.\n` +
+    `  • Use a local path:   ping-lf init <dir> --local <path>\n`).pipe(Effect.andThen(Effect.die(err)))), Effect.catchTag('InvalidComponentNameError', (err) => Console.error(`\nError: "${err.name}" is not a valid component name.\n` +
+    `  Names must be PascalCase, start with an uppercase letter, and contain only letters and digits.\n` +
+    `  Examples: MyCallback, JWTLogin, DefaultStage\n`).pipe(Effect.andThen(Effect.die(err)))), Effect.catchTag('ComponentAlreadyExistsError', (err) => Console.error(`\nError: component directory already exists: ${err.path}\n` +
+    `  Choose a different name or delete the existing directory first.\n`).pipe(Effect.andThen(Effect.die(err)))), Effect.provide(GithubReleaseLayer), Effect.provide(NodeContext.layer), (effect) => NodeRuntime.runMain(effect, { disableErrorReporting: true }));

package/dist/src/services/file-system.d.ts

@@ -0,0 +1,13 @@
+import { Effect } from 'effect';
+import { FileSystem } from '@effect/platform';
+import { FileSystemError } from '../errors.js';
+/**
+ * Returns true if the given directory looks like an initialized framework
+ * project. Checks for `package.json` combined with either an `experimental/`
+ * subdirectory or a `pnpm-workspace.yaml` file — both are reliable indicators
+ * that the directory was created by `ping-lf init`.
+ */
+export declare const isFrameworkDirectory: (dir: string) => Effect.Effect<boolean, never, FileSystem.FileSystem>;
+/** Expand a leading `~` to the user's home directory. */
+export declare function expandTilde(p: string): string;
+export declare const copyWithExclusions: (sourceDir: string, targetDir: string) => Effect.Effect<void, FileSystemError, FileSystem.FileSystem>;

package/dist/src/services/file-system.js

@@ -0,0 +1,64 @@
+import { Effect } from 'effect';
+import { FileSystem } from '@effect/platform';
+import { isExcluded } from '../config/exclusions.js';
+import { FileSystemError } from '../errors.js';
+import path from 'node:path';
+import { normalizeSeparators } from '../utils.js';
+const wrapFsCall = (operation, fsPath) => (effect) => {
+    const fail = (cause) => Effect.fail(new FileSystemError({ operation, path: fsPath, cause }));
+    return effect.pipe(Effect.catchTags({ SystemError: fail, BadArgument: fail }));
+};
+/**
+ * Returns true if the given directory looks like an initialized framework
+ * project. Checks for `package.json` combined with either an `experimental/`
+ * subdirectory or a `pnpm-workspace.yaml` file — both are reliable indicators
+ * that the directory was created by `ping-lf init`.
+ */
+export const isFrameworkDirectory = Effect.fnUntraced(function* (dir) {
+    const fs = yield* FileSystem.FileSystem;
+    const check = (p) => fs.exists(path.join(dir, p)).pipe(Effect.orElseSucceed(() => false));
+    const hasPkgJson = yield* check('package.json');
+    const hasExperimental = yield* check('experimental');
+    const hasPnpmWorkspace = yield* check('pnpm-workspace.yaml');
+    return hasPkgJson && (hasExperimental || hasPnpmWorkspace);
+});
+const PROTECTED_DIRS = ['experimental/custom/callbacks/', 'experimental/custom/stages/'];
+/** Expand a leading `~` to the user's home directory. */
+export function expandTilde(p) {
+    if (p === '~' || p.startsWith('~/') || p.startsWith('~\\')) {
+        const home = process.env.HOME ?? process.env.USERPROFILE ?? '~';
+        return p.replace('~', home);
+    }
+    return p;
+}
+function isProtected(relativePath) {
+    const normalized = normalizeSeparators(relativePath);
+    return PROTECTED_DIRS.some((dir) => `${normalized}/`.startsWith(dir));
+}
+const walk = (fs, sourceDir, targetDir, dir) => Effect.gen(function* () {
+    const entries = yield* fs.readDirectory(dir).pipe(wrapFsCall('readDirectory', dir));
+    yield* Effect.forEach(entries.filter((entry) => {
+        const relativePath = path.relative(sourceDir, path.join(dir, entry));
+        return !isExcluded(relativePath) && !isProtected(relativePath);
+    }), (entry) => Effect.gen(function* () {
+        const fullPath = path.join(dir, entry);
+        const relativePath = path.relative(sourceDir, fullPath);
+        const stat = yield* fs.stat(fullPath).pipe(wrapFsCall('stat', fullPath));
+        const targetPath = path.join(targetDir, relativePath);
+        yield* Effect.if(stat.type === 'Directory', {
+            onTrue: () => fs
+                .makeDirectory(targetPath, { recursive: true })
+                .pipe(wrapFsCall('makeDirectory', targetPath), Effect.andThen(walk(fs, sourceDir, targetDir, fullPath))),
+            onFalse: () => {
+                const parentDir = path.dirname(targetPath);
+                return fs
+                    .makeDirectory(parentDir, { recursive: true })
+                    .pipe(wrapFsCall('makeDirectory', parentDir), Effect.andThen(fs.copyFile(fullPath, targetPath).pipe(wrapFsCall('copyFile', fullPath))));
+            },
+        });
+    }), { concurrency: 'unbounded' });
+});
+export const copyWithExclusions = (sourceDir, targetDir) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    yield* walk(fs, sourceDir, targetDir, sourceDir);
+});

package/dist/src/services/registry.d.ts

@@ -0,0 +1,22 @@
+import { Effect } from 'effect';
+import { FileSystem, Path } from '@effect/platform';
+import { RegistryScanError } from '../errors.js';
+type ComponentType = 'stage' | 'callback';
+/** Extracts names of all `export let` prop declarations from a Svelte component's `<script>` block. */
+export declare function parseAcceptedProps(content: string): string[];
+/** Parses and validates the leading `<!-- @component -->` block from a Svelte file. */
+export declare const parseComponentHeader: (filePath: string, content: string) => Effect.Effect<{
+    type: ComponentType;
+    name: string;
+}, RegistryScanError>;
+/**
+ * Scans `experimental/custom/stages/` and `experimental/custom/callbacks/` for
+ * `@component`-annotated Svelte files and writes
+ * `core/journey/_utilities/custom-registry.ts`.
+ *
+ * All I/O runs in-process via the platform `FileSystem` service — no subprocess
+ * spawning. Validation errors across multiple components are collected and
+ * reported together.
+ */
+export declare const runRegistryScript: (projectDir: string) => Effect.Effect<void, RegistryScanError, FileSystem.FileSystem | Path.Path>;
+export {};

package/dist/src/services/registry.js

@@ -0,0 +1,169 @@
+import { Console, Effect } from 'effect';
+import { FileSystem, Path } from '@effect/platform';
+import { RegistryScanError } from '../errors.js';
+// --------------------------------------------------------------------------
+// Helpers (exported for testing)
+// --------------------------------------------------------------------------
+/** Extracts names of all `export let` prop declarations from a Svelte component's `<script>` block. */
+export function parseAcceptedProps(content) {
+    const scriptMatch = content.match(/<script[^>]*>([\s\S]*?)<\/script>/);
+    if (!scriptMatch)
+        return [];
+    const props = [];
+    const regex = /export\s+let\s+(\w+)/g;
+    let m;
+    while ((m = regex.exec(scriptMatch[1])) !== null)
+        props.push(m[1]);
+    return props;
+}
+function toPascalCase(str) {
+    return str
+        .replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase())
+        .replace(/^(.)/, (_, chr) => chr.toUpperCase());
+}
+/** Parses and validates the leading `<!-- @component -->` block from a Svelte file. */
+export const parseComponentHeader = (filePath, content) => {
+    const fail = (cause) => Effect.fail(new RegistryScanError({ directory: filePath, cause }));
+    const commentMatch = content.match(/^<!--([\s\S]*?)-->/);
+    if (!commentMatch)
+        return fail('Missing @component header. Every custom component must begin with:\n' +
+            '<!--\n   @component\n   Type: stage|callback\n   Name: <ComponentName>\n   -->');
+    const block = commentMatch[1];
+    if (!block.includes('@component'))
+        return fail('Missing "@component" tag in the opening comment.');
+    const typeMatch = block.match(/Type:\s*(\S+)/);
+    if (!typeMatch)
+        return fail('Missing "Type:" field in @component header. Expected: Type: stage or Type: callback');
+    const rawType = typeMatch[1].toLowerCase();
+    if (rawType !== 'stage' && rawType !== 'callback')
+        return fail(`Invalid Type value "${typeMatch[1]}". Must be "stage" or "callback".`);
+    const nameMatch = block.match(/Name:\s*(.+)/);
+    if (!nameMatch)
+        return fail('Missing "Name:" field in @component header. Expected: Name: <ComponentName>');
+    return Effect.succeed({ type: rawType, name: nameMatch[1].trim() });
+};
+// --------------------------------------------------------------------------
+// File scanning
+// --------------------------------------------------------------------------
+const findSvelteFiles = (fs, path, dir) => fs.exists(dir).pipe(Effect.orElseSucceed(() => false), Effect.flatMap((exists) => !exists
+    ? Effect.succeed([])
+    : fs.readDirectory(dir).pipe(Effect.mapError((cause) => new RegistryScanError({ directory: dir, cause })), Effect.flatMap((entries) => Effect.forEach(entries, (entry) => {
+        const fullPath = path.join(dir, entry);
+        return fs.stat(fullPath).pipe(Effect.mapError((cause) => new RegistryScanError({ directory: dir, cause })), Effect.flatMap((stat) => stat.type === 'Directory'
+            ? findSvelteFiles(fs, path, fullPath)
+            : Effect.succeed(entry.endsWith('.svelte') && !entry.endsWith('.story.svelte')
+                ? [fullPath]
+                : [])));
+    }, { concurrency: 'unbounded' })), Effect.map((nested) => nested.flat()))));
+const scanDirectory = (fs, path, dir, expectedType) => findSvelteFiles(fs, path, dir).pipe(Effect.flatMap((files) => Effect.validateAll(files, (filePath) => fs.readFileString(filePath).pipe(Effect.mapError((cause) => new RegistryScanError({ directory: filePath, cause })), Effect.flatMap((content) => parseComponentHeader(filePath, content).pipe(Effect.flatMap(({ type, name }) => type !== expectedType
+    ? Effect.fail(new RegistryScanError({
+        directory: filePath,
+        cause: `Component in /experimental/custom/${expectedType}s/ declares Type: "${type}". Must declare Type: ${expectedType}`,
+    }))
+    : Effect.succeed({
+        filePath,
+        name,
+        type,
+        acceptedProps: parseAcceptedProps(content),
+    })))))).pipe(Effect.mapError((errors) => new RegistryScanError({
+    directory: dir,
+    cause: errors.map((e) => String(e.cause)).join('\n'),
+})))));
+// --------------------------------------------------------------------------
+// Registry content builder (pure)
+// --------------------------------------------------------------------------
+function buildRegistryContent(path, registryDir, stageComponents, callbackComponents) {
+    const toEntry = (prefix) => ({ filePath, name, acceptedProps }) => {
+        const relPath = path.relative(registryDir, filePath).replace(/\\/g, '/');
+        const importPath = relPath.startsWith('.') ? relPath : `./${relPath}`;
+        return { varName: `${prefix}${toPascalCase(name)}`, importPath, name, acceptedProps };
+    };
+    const stageEntries = stageComponents.map(toEntry('Stage'));
+    const callbackEntries = callbackComponents.map(toEntry('Callback'));
+    const lines = [
+        `/**`,
+        ` * AUTO-GENERATED — do not edit by hand.`,
+        ` * Run \`pnpm build:widget\` or \`pnpm --filter @forgerock/login-widget exec vite build\` to regenerate.`,
+        ` *`,
+        ` * Source: /experimental/custom/stages/ and /experimental/custom/callbacks/`,
+        ` */`,
+        ``,
+        `import type { Component } from 'svelte';`,
+        ``,
+        `export interface CustomRegistryEntry {`,
+        `  component: Component;`,
+        `  /** Props declared via \`export let\` in the component — only these are forwarded by the mapper. */`,
+        `  acceptedProps: string[];`,
+        `}`,
+        ``,
+    ];
+    if (stageEntries.length > 0) {
+        lines.push(`// Stage overrides / extensions`);
+        for (const { varName, importPath } of stageEntries)
+            lines.push(`import ${varName} from '${importPath}';`);
+        lines.push(``);
+    }
+    if (callbackEntries.length > 0) {
+        lines.push(`// Callback overrides / extensions`);
+        for (const { varName, importPath } of callbackEntries)
+            lines.push(`import ${varName} from '${importPath}';`);
+        lines.push(``);
+    }
+    lines.push(`export const customStageRegistry: Record<string, CustomRegistryEntry> = {`);
+    for (const { varName, name, acceptedProps } of stageEntries)
+        lines.push(`  ${JSON.stringify(name)}: { component: ${varName}, acceptedProps: ${JSON.stringify(acceptedProps)} },`);
+    lines.push(`};`);
+    lines.push(``);
+    lines.push(`export const customCallbackRegistry: Record<string, CustomRegistryEntry> = {`);
+    for (const { varName, name, acceptedProps } of callbackEntries)
+        lines.push(`  ${JSON.stringify(name)}: { component: ${varName}, acceptedProps: ${JSON.stringify(acceptedProps)} },`);
+    lines.push(`};`);
+    lines.push(``);
+    return lines.join('\n');
+}
+// --------------------------------------------------------------------------
+// Public API
+// --------------------------------------------------------------------------
+/**
+ * Scans `experimental/custom/stages/` and `experimental/custom/callbacks/` for
+ * `@component`-annotated Svelte files and writes
+ * `core/journey/_utilities/custom-registry.ts`.
+ *
+ * All I/O runs in-process via the platform `FileSystem` service — no subprocess
+ * spawning. Validation errors across multiple components are collected and
+ * reported together.
+ */
+export const runRegistryScript = (projectDir) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const stageDir = path.join(projectDir, 'experimental', 'custom', 'stages');
+    const callbackDir = path.join(projectDir, 'experimental', 'custom', 'callbacks');
+    const registryDir = path.join(projectDir, 'core', 'journey', '_utilities');
+    const registryPath = path.join(registryDir, 'custom-registry.ts');
+    const [stageComponents, callbackComponents] = yield* Effect.all([
+        scanDirectory(fs, path, stageDir, 'stage'),
+        scanDirectory(fs, path, callbackDir, 'callback'),
+    ], { concurrency: 'unbounded' });
+    const content = buildRegistryContent(path, registryDir, stageComponents, callbackComponents);
+    yield* fs
+        .makeDirectory(registryDir, { recursive: true })
+        .pipe(Effect.mapError((cause) => new RegistryScanError({ directory: registryDir, cause })));
+    yield* fs
+        .writeFileString(registryPath, content)
+        .pipe(Effect.mapError((cause) => new RegistryScanError({ directory: registryPath, cause })));
+    const total = stageComponents.length + callbackComponents.length;
+    if (total === 0) {
+        yield* Console.log(`custom-registry.ts generated (no custom components found — registries are empty)`);
+    }
+    else {
+        yield* Console.log(`custom-registry.ts generated:`);
+        if (stageComponents.length > 0)
+            yield* Console.log(`  Stages    (${stageComponents.length}): ${stageComponents
+                .map((c) => c.name)
+                .join(', ')}`);
+        if (callbackComponents.length > 0)
+            yield* Console.log(`  Callbacks (${callbackComponents.length}): ${callbackComponents
+                .map((c) => c.name)
+                .join(', ')}`);
+    }
+});

package/dist/src/services/release.d.ts

@@ -0,0 +1,27 @@
+import { Context, Effect, Layer, Scope } from 'effect';
+import { FileSystem, HttpClient } from '@effect/platform';
+import { InvalidVersionError, ReleaseFsError, ReleaseNetworkError, ReleaseNotFoundError, ReleaseParseError } from '../errors.js';
+export declare function validateVersion(version: string): Effect.Effect<string, InvalidVersionError>;
+/**
+ * Parses a GitHub releases API JSON response and returns an array of
+ * `{ tag, publishedAt }` objects, excluding drafts and pre-releases.
+ */
+export declare function parseReleaseTags(json: string): Effect.Effect<Array<{
+    tag: string;
+    publishedAt: string;
+}>, ReleaseParseError>;
+declare const Release_base: Context.TagClass<Release, "Release", {
+    readonly archiveUrl: (version: string) => string;
+    readonly resolveLatest: () => Effect.Effect<string, ReleaseNetworkError | ReleaseParseError>;
+    readonly listReleases: () => Effect.Effect<Array<{
+        tag: string;
+        publishedAt: string;
+    }>, ReleaseNetworkError | ReleaseParseError | ReleaseNotFoundError>;
+    readonly fetch: (version: string, targetDir: string) => Effect.Effect<string, InvalidVersionError | ReleaseFsError | ReleaseNetworkError | ReleaseParseError, FileSystem.FileSystem | Scope.Scope>;
+    readonly fetchBranch: (branch: string, targetDir: string) => Effect.Effect<string, ReleaseFsError | ReleaseNetworkError | ReleaseParseError, FileSystem.FileSystem | Scope.Scope>;
+}>;
+export declare class Release extends Release_base {
+}
+export declare const makeGithubReleaseLayer: (httpLayer: Layer.Layer<HttpClient.HttpClient>) => Layer.Layer<Release, never, never>;
+export declare const GithubReleaseLayer: Layer.Layer<Release, never, never>;
+export {};