@power-plant/core 0.0.25 → 0.0.28

package/dist/execute-C6kyFG8N.mjs

@@ -0,0 +1,461 @@
+import { callAsyncExecutionContext, callAsyncSessionContext } from "./context.mjs";
+import { isGeneratorConfigObject, isInputConfigObject, isOutputConfigObject, isSchemaConfigObject } from "./helpers/type-checks.mjs";
+import { resolveMeta, resolveMetaDescription, resolveMetaExample } from "./helpers/meta.mjs";
+import { uuid } from "@stryke/unique-id/uuid";
+import { getEnvPaths } from "@stryke/env/get-env-paths";
+import { readFileIfExisting } from "@stryke/fs/read-file";
+import { writeFile } from "@stryke/fs/write-file";
+import { joinPaths } from "@stryke/path/join-paths";
+import { isSetString } from "@stryke/type-checks/is-set-string";
+import defu from "defu";
+import os from "node:os";
+import { createStorage } from "unstorage";
+import fsLite from "unstorage/drivers/fs-lite";
+import { mapStorageToFileSystem } from "@power-plant/schema/storage";
+import { load } from "@stryke/resolve/load";
+import { isFunction } from "@stryke/type-checks/is-function";
+import { assertSchemasDoNotContradict, extractSchemaWithSource, mergeMetadata } from "@power-plant/schema";
+import { isLoadReference } from "@stryke/resolve/type-checks";
+
+//#region src/lib/context.ts
+const logger = {
+	debug: console.debug,
+	info: console.info,
+	warn: console.warn,
+	error: console.error
+};
+const paths = getEnvPaths({
+	appId: "power-plant",
+	orgId: "storm-software"
+});
+/**
+* Create a session context for the engine.
+*
+* @param session - The session for the context.
+* @param userConfig - The user configuration.
+* @returns A session context.
+*/
+async function createSessionContext(userConfig = {}) {
+	const cwd = userConfig.cwd || process.cwd();
+	const now = /* @__PURE__ */ new Date();
+	const storage = createStorage({ driver: fsLite({ base: cwd }) });
+	const store = JSON.parse(await readFileIfExisting(joinPaths(paths.data, ".local-store.json")) || "{}");
+	const device = store.device || os.hostname() || uuid();
+	const user = store.user || os.userInfo().username || uuid();
+	if (!isSetString(store.device) || !isSetString(store.user)) await writeFile(joinPaths(paths.data, ".local-store.json"), JSON.stringify({
+		device,
+		user
+	}, null, 2));
+	return defu({
+		cwd,
+		session: {
+			id: uuid(),
+			createdAt: now,
+			updatedAt: now,
+			device,
+			user,
+			executions: []
+		}
+	}, userConfig, {
+		storage,
+		settings: {},
+		logger
+	});
+}
+/**
+* Create an execution context for the engine.
+*
+* @param executionId - The ID of the execution.
+* @param sessionContext - The session context.
+* @param options - The options.
+* @param schema - The schema.
+* @param input - The input.
+* @param output - The output.
+* @returns A promise that resolves to an execution context.
+*/
+async function createExecutionContext(executionId, sessionContext, options, schema, input, output) {
+	const documents = {};
+	const addDocument = (pathOrDocument, document) => {
+		if (isSetString(pathOrDocument)) documents[pathOrDocument] = defu({ path: pathOrDocument }, document, {
+			chunks: [],
+			meta: {}
+		});
+		else documents[pathOrDocument.path] = defu(pathOrDocument, document);
+	};
+	let specValue;
+	const context = {
+		...sessionContext,
+		id: executionId,
+		createdAt: /* @__PURE__ */ new Date(),
+		updatedAt: /* @__PURE__ */ new Date(),
+		options,
+		schema,
+		input,
+		output,
+		documents,
+		spec() {
+			if (!specValue) throw new Error("The specification was accessed prior to the input processing.");
+			return specValue;
+		},
+		addDocument,
+		meta: {
+			id: executionId,
+			executedAt: /* @__PURE__ */ new Date(),
+			executedBy: ""
+		}
+	};
+	Object.defineProperty(context, "~spec", {
+		get() {
+			return specValue;
+		},
+		set(value) {
+			specValue = value;
+		},
+		enumerable: false
+	});
+	return context;
+}
+
+//#endregion
+//#region src/lib/extract.ts
+async function extractExecution(execution, _spec, _options) {
+	return execution;
+}
+
+//#endregion
+//#region src/lib/schema.ts
+/**
+* Extracts and normalizes {@link SchemaMetaConfig | schema metadata} from a given {@link SchemaMetaConfig}. This function ensures that the metadata is in a consistent format, converting version numbers to strings and filtering out any invalid or empty tags.
+*
+* @param schema - The schema from which to extract metadata.
+* @param input - The schema metadata input to extract and normalize.
+* @returns The normalized schema metadata.
+*/
+function extractSchemaMeta(schema, input) {
+	const jsonSchema = schema?.schema ?? {};
+	const meta = resolveMeta(schema, input);
+	meta.description = resolveMetaDescription(`Accepts a ${meta.title ?? ""} specification and processes it with a {title} sink.`, jsonSchema, meta, input?.description);
+	meta.examples = resolveMetaExample(jsonSchema, meta, input?.examples);
+	return meta;
+}
+/**
+* Normalizes any accepted schema input into a concrete schema descriptor.
+*
+* @param input - The schema input to normalize.
+* @param options - Optional options for resolving the schema input.
+* @returns A promise that resolves to a normalized schema descriptor.
+*/
+async function createSchema(input, options = {}) {
+	const { meta, schema } = isSchemaConfigObject(input) ? input : {
+		schema: input,
+		meta: {}
+	};
+	const resolvedSchema = await extractSchemaWithSource(schema, options);
+	return {
+		...resolvedSchema,
+		meta: extractSchemaMeta(resolvedSchema, meta)
+	};
+}
+/**
+* Ensures resolved input/output schema overrides do not contradict the generator schema.
+*
+* @param baseSchema - The resolved generator schema.
+* @param input - The resolved generator input descriptor.
+* @param output - The resolved generator output descriptor.
+*/
+function assertGeneratorConfigSchemasDoNotContradict(baseSchema, input, output) {
+	if (input && input.schema !== baseSchema) assertSchemasDoNotContradict(baseSchema.schema, input.schema.schema, "input");
+	if (output && output.schema !== baseSchema) assertSchemasDoNotContradict(baseSchema.schema, output.schema.schema, "output");
+}
+
+//#endregion
+//#region src/lib/input.ts
+/**
+* Extracts and normalizes input metadata from a given configuration. This function ensures that the metadata is in a consistent format, converting version numbers to strings and filtering out any invalid or empty tags.
+*
+* @param schema - The schema that the input input is expected to conform to.
+* @param input - The input metadata input to extract and normalize.
+* @returns The normalized input metadata.
+*/
+function extractInputMeta(schema, input) {
+	const jsonSchema = schema?.schema ?? {};
+	const meta = resolveMeta(schema, input);
+	meta.description = resolveMetaDescription(`Determines the ${meta.title ?? ""} specification from a {title} input.`, jsonSchema, meta, input?.description);
+	return meta;
+}
+/**
+* Normalizes any accepted input configuration into a concrete input descriptor.
+*
+* @param schema - The schema that the specification is expected to conform to.
+* @param config - The input configuration to normalize.
+* @param options - Optional options for resolving the input configuration.
+* @returns A promise that resolves to a normalized input descriptor.
+*/
+async function createInput(schema, config, options = {}) {
+	const { input, meta, schema: inputSchema } = isInputConfigObject(config) ? config : {
+		input: config,
+		meta: {}
+	};
+	let resolvedSchema = schema;
+	if (inputSchema) {
+		let resolvedInputSchema;
+		if (isLoadReference(inputSchema)) try {
+			resolvedInputSchema = await load(inputSchema, options);
+		} catch {}
+		else resolvedInputSchema = inputSchema;
+		if (resolvedInputSchema) {
+			resolvedSchema = await createSchema(resolvedInputSchema, options);
+			resolvedSchema.schema = mergeMetadata(resolvedSchema.schema, schema.schema);
+		}
+	}
+	let resolvedInput;
+	if (isLoadReference(input)) try {
+		const loaded = await load(input, options);
+		if (isInputConfigObject(loaded)) resolvedInput = await createInput(resolvedSchema, loaded.input, options).then((s) => s.input);
+		else resolvedInput = loaded;
+	} catch {}
+	if (!resolvedInput) resolvedInput = input;
+	return {
+		schema: resolvedSchema,
+		input: resolvedInput,
+		meta: extractInputMeta(resolvedSchema, meta)
+	};
+}
+
+//#endregion
+//#region src/lib/output.ts
+/**
+* Extracts and normalizes output metadata from a given configuration. This function ensures that the metadata is in a consistent format, converting version numbers to strings and filtering out any invalid or empty tags.
+*
+* @param schema - The schema that the specification is expected to conform to.
+* @param config - The output metadata config to extract and normalize.
+* @returns The normalized output metadata.
+*/
+function extractOutputMeta(schema, config) {
+	const jsonSchema = schema?.schema ?? {};
+	const meta = resolveMeta(schema, config);
+	meta.description = resolveMetaDescription(`Accepts a ${meta.title ?? ""} specification and processes it with a {title} output.`, jsonSchema, meta, config?.description);
+	return meta;
+}
+/**
+* Normalizes any accepted output config into a concrete output descriptor.
+*
+* @param schema - The schema that the output config is expected to conform to.
+* @param config - The output config to normalize.
+* @param options - Optional options for resolving the output config.
+* @returns A promise that resolves to a normalized output descriptor.
+*/
+async function createOutput(schema, config, options = {}) {
+	const { output, meta, schema: configSchema } = isOutputConfigObject(config) ? config : {
+		output: config,
+		meta: {}
+	};
+	let resolvedSchema = schema;
+	if (configSchema) {
+		let resolvedConfigSchema;
+		if (isLoadReference(configSchema)) try {
+			resolvedConfigSchema = await load(configSchema, options);
+		} catch {}
+		else resolvedConfigSchema = configSchema;
+		if (resolvedConfigSchema) {
+			resolvedSchema = await createSchema(resolvedConfigSchema, options);
+			resolvedSchema.schema = mergeMetadata(resolvedSchema.schema, schema.schema);
+		}
+	}
+	let resolvedOutput;
+	if (isLoadReference(output)) try {
+		const loaded = await load(output, options);
+		if (isOutputConfigObject(loaded)) resolvedOutput = await createOutput(resolvedSchema, loaded.output, options).then((s) => s.output);
+		else resolvedOutput = loaded;
+	} catch {}
+	if (!resolvedOutput) resolvedOutput = output;
+	return {
+		schema: resolvedSchema,
+		output: resolvedOutput,
+		meta: extractOutputMeta(resolvedSchema, meta)
+	};
+}
+
+//#endregion
+//#region src/lib/generator.ts
+/**
+* Creates a generator from raw schema/input/output configurations and resolves all descriptors.
+*
+* @remarks
+* This function is used to create a generator from raw schema, input, and output configurations. It resolves all descriptors and returns a fully constructed generator that can be used to generate output based on the provided schema and options.
+*
+* @template TSpec - The type of the specification that the generator will produce.
+* @template TOptions - The type of the options that will be passed to the generator during generation.
+* @param config - The generator configuration containing schema, input, output, and optional meta information.
+* @param options - Optional extraction options for schema, input, and output.
+* @returns A promise that resolves to a fully constructed generator.
+*/
+async function createGenerator(executionId, sessionContext, config, options = {}) {
+	let configObject;
+	if (isGeneratorConfigObject(config)) configObject = config;
+	else configObject = await load(config, {
+		fs: mapStorageToFileSystem(sessionContext.storage),
+		...options
+	});
+	if (!configObject.schema) configObject.schema = { type: "any" };
+	const schema = await createSchema(configObject.schema, {
+		storage: sessionContext.storage,
+		tsconfig: options.tsconfig,
+		...options
+	});
+	let inputConfig = configObject.input;
+	if (!inputConfig) if (options.inputPath) inputConfig = "@power-plant/unstorage-input";
+	else throw new Error("No input configuration provided. Please provide an input configuration, a valid specification, or a `inputPath` option that points to a valid input file.");
+	let outputConfig = configObject.output;
+	if (!outputConfig) outputConfig = "@power-plant/unstorage-output";
+	const [input, output] = await Promise.all([createInput(schema, inputConfig, {
+		storage: sessionContext.storage,
+		...options
+	}), createOutput(schema, outputConfig, {
+		storage: sessionContext.storage,
+		...options
+	})]);
+	assertGeneratorConfigSchemasDoNotContradict(schema, input, output);
+	const generator = async (options) => {
+		const context = await createExecutionContext(executionId, sessionContext, options, schema, input, output);
+		return callAsyncExecutionContext(context, async () => {
+			const spec = isFunction(input.input) ? await input.input({
+				storage: context.storage,
+				...options
+			}) : input.input;
+			context["~spec"] = spec;
+			let generatorFn;
+			if (isFunction(configObject.generator)) generatorFn = configObject.generator;
+			else generatorFn = await load(configObject.generator, {
+				storage: context.storage,
+				...options
+			});
+			const documents = await generatorFn(spec, options);
+			return {
+				spec,
+				options,
+				documents,
+				returns: await output.output(spec, options, documents)
+			};
+		});
+	};
+	return {
+		meta: configObject.meta,
+		schema,
+		input,
+		output,
+		generator
+	};
+}
+
+//#endregion
+//#region src/execute.ts
+/**
+* Creates an execution function that can be used to execute a generator.
+*
+* @remarks
+* This function is used to create an execution function that can be used to execute a generator. It creates a new execution context and returns an execution function that can be used to execute the generator with the given configuration and options.
+*
+*
+* @example
+* ```ts
+* import { createExecute } from "@power-plant/core";
+*
+* // First, create an execution function with a custom configuration
+* const execute = await createExecute({
+*  ...
+* });
+*
+* // Then, execute the generator
+* const result = await execute("my-generator", {
+*  ...
+* });
+* ```
+*
+* @example
+* ```ts
+* import { createExecute } from "@power-plant/core";
+*
+* // First, create an execution function with a custom configuration
+* const execute = await createExecute({
+*  ...
+* });
+*
+* // Then, execute the generator
+* const result = await execute({
+*  generator: (spec, options) => { ... },
+*  ...
+* });
+* ```
+*
+* @template TSpec - The type of the specification that the generator will produce.
+* @template TOptions - The type of the options that will be passed to the generator during generation.
+* @template TReturns - The type of the returns that the generator will produce.
+* @param userConfig - The user configuration for the engine.
+* @returns A promise that resolves to an execution function.
+*/
+async function createExecute(userConfig = {}) {
+	const context = await createSessionContext(userConfig);
+	const execute = async (config, options = {}) => callAsyncSessionContext(context, async () => {
+		const executionId = uuid();
+		const { generator } = await createGenerator(executionId, context, config, options);
+		const { documents, returns, spec, options: returnedOptions } = await generator(options);
+		const execution = await extractExecution({
+			documents: Object.fromEntries(Object.entries(documents).map(([path, document]) => [path, {
+				...document,
+				path,
+				meta: { executionId }
+			}])),
+			meta: {
+				executionId,
+				executedAt: /* @__PURE__ */ new Date(),
+				executedBy: context.session.user
+			}
+		}, spec, returnedOptions);
+		context.session.executions.push(execution);
+		return returns;
+	});
+	return execute;
+}
+/**
+* Executes a generator with a given configuration and options.
+*
+* @remarks
+* This function is used to execute a generator with a given configuration and options. It creates a new execution context and returns an execution function that can be used to execute the generator with the given configuration and options.
+*
+* @example
+* ```ts
+* import { execute } from "@power-plant/core";
+*
+* // Create and execute the generator
+* const result = await execute("my-generator", {
+*  ...
+* });
+* ```
+*
+* @example
+* ```ts
+* import { execute } from "@power-plant/core";
+*
+* // Create and execute the generator
+* const result = await execute({
+*  generator: (spec, options) => { ... },
+* }, {
+*  ...
+* });
+* ```
+*
+* @template TSpec - The type of the specification that the generator will produce.
+* @template TOptions - The type of the options that will be passed to the generator during generation.
+* @template TReturns - The type of the returns that the generator will produce.
+* @param config - The configuration for the generator.
+* @param options - The options for the generator.
+* @returns A promise that resolves to the returns of the generator.
+*/
+async function execute(config, options = {}) {
+	return (await createExecute(options))(config, options);
+}
+
+//#endregion
+export { execute as n, createExecute as t };
+//# sourceMappingURL=execute-C6kyFG8N.mjs.map

package/dist/execute-C6kyFG8N.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute-C6kyFG8N.mjs","names":[],"sources":[],"mappings":""}

package/dist/execute.cjs

@@ -1 +1,6 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./execute-4whFNgY3.cjs");require("./context.cjs"),exports.createExecute=e.t,exports.execute=e.n;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_execute = require('./execute-3oK9lgh3.cjs');
+require('./context.cjs');
+
+exports.createExecute = require_execute.createExecute;
+exports.execute = require_execute.execute;

package/dist/execute.mjs

@@ -1 +1,4 @@
-import"./context.mjs";import{n as e,t}from"./execute-ByonuMsd.mjs";export{t as createExecute,e as execute};
+import "./context.mjs";
+import { n as execute, t as createExecute } from "./execute-C6kyFG8N.mjs";
+
+export { createExecute, execute };

package/dist/helpers/index.cjs

@@ -1 +1,17 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./type-checks.cjs"),t=require("./meta.cjs");exports.formatMetaVersion=t.formatMetaVersion,exports.isGeneratorConfigObject=e.isGeneratorConfigObject,exports.isInputConfigObject=e.isInputConfigObject,exports.isOutputConfigObject=e.isOutputConfigObject,exports.isSchemaConfigObject=e.isSchemaConfigObject,exports.resolveMeta=t.resolveMeta,exports.resolveMetaDescription=t.resolveMetaDescription,exports.resolveMetaExample=t.resolveMetaExample,exports.resolveMetaId=t.resolveMetaId,exports.resolveMetaLinks=t.resolveMetaLinks,exports.resolveMetaName=t.resolveMetaName,exports.resolveMetaTitle=t.resolveMetaTitle,exports.resolveMetaVersion=t.resolveMetaVersion;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_helpers_type_checks = require('./type-checks.cjs');
+const require_helpers_meta = require('./meta.cjs');
+
+exports.formatMetaVersion = require_helpers_meta.formatMetaVersion;
+exports.isGeneratorConfigObject = require_helpers_type_checks.isGeneratorConfigObject;
+exports.isInputConfigObject = require_helpers_type_checks.isInputConfigObject;
+exports.isOutputConfigObject = require_helpers_type_checks.isOutputConfigObject;
+exports.isSchemaConfigObject = require_helpers_type_checks.isSchemaConfigObject;
+exports.resolveMeta = require_helpers_meta.resolveMeta;
+exports.resolveMetaDescription = require_helpers_meta.resolveMetaDescription;
+exports.resolveMetaExample = require_helpers_meta.resolveMetaExample;
+exports.resolveMetaId = require_helpers_meta.resolveMetaId;
+exports.resolveMetaLinks = require_helpers_meta.resolveMetaLinks;
+exports.resolveMetaName = require_helpers_meta.resolveMetaName;
+exports.resolveMetaTitle = require_helpers_meta.resolveMetaTitle;
+exports.resolveMetaVersion = require_helpers_meta.resolveMetaVersion;

package/dist/helpers/index.mjs

@@ -1 +1,4 @@
-import{isGeneratorConfigObject as e,isInputConfigObject as t,isOutputConfigObject as n,isSchemaConfigObject as r}from"./type-checks.mjs";import{formatMetaVersion as i,resolveMeta as a,resolveMetaDescription as o,resolveMetaExample as s,resolveMetaId as c,resolveMetaLinks as l,resolveMetaName as u,resolveMetaTitle as d,resolveMetaVersion as f}from"./meta.mjs";export{i as formatMetaVersion,e as isGeneratorConfigObject,t as isInputConfigObject,n as isOutputConfigObject,r as isSchemaConfigObject,a as resolveMeta,o as resolveMetaDescription,s as resolveMetaExample,c as resolveMetaId,l as resolveMetaLinks,u as resolveMetaName,d as resolveMetaTitle,f as resolveMetaVersion};
+import { isGeneratorConfigObject, isInputConfigObject, isOutputConfigObject, isSchemaConfigObject } from "./type-checks.mjs";
+import { formatMetaVersion, resolveMeta, resolveMetaDescription, resolveMetaExample, resolveMetaId, resolveMetaLinks, resolveMetaName, resolveMetaTitle, resolveMetaVersion } from "./meta.mjs";
+
+export { formatMetaVersion, isGeneratorConfigObject, isInputConfigObject, isOutputConfigObject, isSchemaConfigObject, resolveMeta, resolveMetaDescription, resolveMetaExample, resolveMetaId, resolveMetaLinks, resolveMetaName, resolveMetaTitle, resolveMetaVersion };

package/dist/helpers/meta.cjs

@@ -1 +1,142 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});let e=require("@stryke/string-format/title-case"),t=require("@stryke/type-checks/is-set-object"),n=require("@stryke/unique-id/uuid"),r=require("@stryke/type-checks/is-set-string"),i=require("@power-plant/schema"),a=require("@power-plant/schema/codegen"),o=require("@stryke/convert/to-array"),s=require("@stryke/date/format"),c=require("@stryke/date/validate"),l=require("@stryke/helpers/get-unique"),u=require("@stryke/string-format/kebab-case"),d=require("@stryke/type-checks/is-date"),f=require("@stryke/type-checks/is-number");function p(e){return(0,d.isDate)(e)?(0,s.formatYYYYMMDD)(e):(0,f.isNumber)(e)?(0,c.isValidTimestamp)(e)&&e>1e9?(0,s.formatYYYYMMDD)(new Date(e)):e.toString():(0,r.isSetString)(e)?e:`1.0`}function m(e,t,n){return p(n??t?.version??e?.version)}function h(e,t,n){return n??t.name??((0,r.isSetString)(e?.name)?e.name:(0,r.isSetString)(e?.title)?e.title:e.$id?(0,u.kebabCase)(e.$id):(0,a.stringifyType)(e))}function g(e,t){let r=h(e,t),i=m(e,t);return r?`${(0,u.kebabCase)(r)}@${i}`:(0,n.uuid)()}function _(t,n,r){let i=r??n.title??t?.title;return i===void 0?(0,e.titleCase)(n.name??(0,a.stringifyType)(t)):i}function v(e,t,n,i){n.title??=_(t,n);let a=n.title??``,o=e.replaceAll(/\{\s*title\s*\}/g,a),s=i??n.description??t?.description;return(0,r.isSetString)(s)?s:o}function y(e,n,i){return(e=>e.map((e,n)=>(0,r.isSetString)(e)?{name:`example-${n+1}`,description:`Example Specification #${n+1}`,value:e}:(0,t.isSetObject)(e)&&`value`in e&&(0,r.isSetString)(e.value)?{name:`example-${n+1}`,description:e.description||`Example Specification #${n+1}`,value:e.value}:void 0).filter(Boolean))((0,o.toArray)(i??n.examples??e?.examples??[]))}function b(e,t,n){return(0,l.getUnique)((0,o.toArray)(n).concat(t.links??[]).concat(e?.docs??[]))}function x(e,t){let n=(0,i.isSchemaOf)(e)?e:e??{schema:{}},r={};return r.name=h(n.schema,r,t?.name),r.version=m(n?.schema,r,t?.version),r.title=_(n?.schema,r,t?.title),r.links=b(n?.schema,r,t?.links),t?.deprecated&&(r.deprecated=t?.deprecated),t?.usage&&(r.usage=t?.usage),t?.tags&&(r.tags=t?.tags),r}exports.formatMetaVersion=p,exports.resolveMeta=x,exports.resolveMetaDescription=v,exports.resolveMetaExample=y,exports.resolveMetaId=g,exports.resolveMetaLinks=b,exports.resolveMetaName=h,exports.resolveMetaTitle=_,exports.resolveMetaVersion=m;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _stryke_string_format_title_case = require("@stryke/string-format/title-case");
+let _stryke_type_checks_is_set_object = require("@stryke/type-checks/is-set-object");
+let _stryke_unique_id_uuid = require("@stryke/unique-id/uuid");
+let _stryke_type_checks_is_set_string = require("@stryke/type-checks/is-set-string");
+let _power_plant_schema = require("@power-plant/schema");
+let _power_plant_schema_codegen = require("@power-plant/schema/codegen");
+let _stryke_convert_to_array = require("@stryke/convert/to-array");
+let _stryke_date_format = require("@stryke/date/format");
+let _stryke_date_validate = require("@stryke/date/validate");
+let _stryke_helpers_get_unique = require("@stryke/helpers/get-unique");
+let _stryke_string_format_kebab_case = require("@stryke/string-format/kebab-case");
+let _stryke_type_checks_is_date = require("@stryke/type-checks/is-date");
+let _stryke_type_checks_is_number = require("@stryke/type-checks/is-number");
+
+//#region src/helpers/meta.ts
+function formatMetaVersion(value) {
+	return (0, _stryke_type_checks_is_date.isDate)(value) ? (0, _stryke_date_format.formatYYYYMMDD)(value) : (0, _stryke_type_checks_is_number.isNumber)(value) ? (0, _stryke_date_validate.isValidTimestamp)(value) && value > 1e9 ? (0, _stryke_date_format.formatYYYYMMDD)(new Date(value)) : value.toString() : (0, _stryke_type_checks_is_set_string.isSetString)(value) ? value : "1.0";
+}
+/**
+* Extracts the version information from a given input, which can be a string, number, or Date object. The function returns a string representation of the version in the format "YYYYMMDD" for Date inputs, or as a string for valid timestamp numbers. If the input is a string, it is returned as-is. If the input is invalid or not provided, a default version of "1.0" is returned.
+*
+* @param input - The input from which to extract the version. It can be a string, number, undefined, or Date object.
+* @returns A string representing the extracted version information.
+*/
+function resolveMetaVersion(schema, meta, input) {
+	return formatMetaVersion(input ?? meta?.version ?? schema?.version);
+}
+/**
+* Resolves a metadata name using explicit input, metadata, or schema fallbacks.
+*
+* @param schema - The JSON Schema fragment to read fallback values from.
+* @param meta - Metadata values that may already include a name.
+* @param input - An explicit name value to prioritize when provided.
+* @returns The resolved metadata name.
+*/
+function resolveMetaName(schema, meta, input) {
+	return input ?? meta.name ?? ((0, _stryke_type_checks_is_set_string.isSetString)(schema?.name) ? schema.name : (0, _stryke_type_checks_is_set_string.isSetString)(schema?.title) ? schema.title : schema.$id ? (0, _stryke_string_format_kebab_case.kebabCase)(schema.$id) : (0, _power_plant_schema_codegen.stringifyType)(schema));
+}
+/**
+* Resolves a stable metadata identifier in the format `<name>@<version>`.
+*
+* @param schema - The JSON Schema fragment used to infer fallback values.
+* @param meta - Metadata values used to resolve name and version.
+* @returns The resolved metadata identifier, or a generated id when no name is available.
+*/
+function resolveMetaId(schema, meta) {
+	const name = resolveMetaName(schema, meta);
+	const version = resolveMetaVersion(schema, meta);
+	return name ? `${(0, _stryke_string_format_kebab_case.kebabCase)(name)}@${version}` : (0, _stryke_unique_id_uuid.uuid)();
+}
+/**
+* Resolves a human-readable display name for metadata.
+*
+* @param schema - The JSON Schema fragment to read fallback display values from.
+* @param meta - Metadata values that may already include a display name.
+* @param input - An explicit display name value to prioritize when provided.
+* @returns The resolved metadata display name.
+*/
+function resolveMetaTitle(schema, meta, input) {
+	const value = input ?? meta.title ?? schema?.title;
+	if (value !== void 0) return value;
+	return (0, _stryke_string_format_title_case.titleCase)(meta.name ?? (0, _power_plant_schema_codegen.stringifyType)(schema));
+}
+/**
+* Resolves a metadata description from explicit input, metadata, or schema values.
+*
+* @param template - A template string used to generate a default description when no explicit description is provided.
+* @param schema - The JSON Schema fragment to read fallback description values from.
+* @param meta - Metadata values that may already include a description.
+* @param input - An explicit description value to prioritize when provided.
+* @returns The resolved description, if available.
+*/
+function resolveMetaDescription(template, schema, meta, input) {
+	meta.title ??= resolveMetaTitle(schema, meta);
+	const title = meta.title ?? "";
+	const defaultDescription = template.replaceAll(/\{\s*title\s*\}/g, title);
+	const resolved = input ?? meta.description ?? schema?.description;
+	return (0, _stryke_type_checks_is_set_string.isSetString)(resolved) ? resolved : defaultDescription;
+}
+/**
+* Resolves and normalizes metadata examples into a consistent object format.
+*
+* @typeParam TSpec - The schema specification type associated with example values.
+* @param schema - The JSON Schema fragment to read fallback examples from.
+* @param meta - Metadata values that may already include examples.
+* @param input - Explicit examples to prioritize when provided.
+* @returns A normalized list of examples with generated descriptions when needed.
+*/
+function resolveMetaExample(schema, meta, input) {
+	const normalizeExamples = (examples) => examples.map((example, i) => (0, _stryke_type_checks_is_set_string.isSetString)(example) ? {
+		name: `example-${i + 1}`,
+		description: `Example Specification #${i + 1}`,
+		value: example
+	} : (0, _stryke_type_checks_is_set_object.isSetObject)(example) && "value" in example && (0, _stryke_type_checks_is_set_string.isSetString)(example.value) ? {
+		name: `example-${i + 1}`,
+		description: example.description || `Example Specification #${i + 1}`,
+		value: example.value
+	} : void 0).filter(Boolean);
+	return normalizeExamples((0, _stryke_convert_to_array.toArray)(input ?? meta.examples ?? schema?.examples ?? []));
+}
+/**
+* Resolves and de-duplicates metadata links from input, metadata, and schema docs.
+*
+* @param schema - The JSON Schema fragment to read fallback documentation links from.
+* @param meta - Metadata values that may already include links.
+* @param input - Explicit links to prioritize when provided.
+* @returns A unique list of metadata links.
+*/
+function resolveMetaLinks(schema, meta, input) {
+	return (0, _stryke_helpers_get_unique.getUnique)((0, _stryke_convert_to_array.toArray)(input).concat(meta.links ?? []).concat(schema?.docs ?? []));
+}
+/**
+* Extracts and normalizes metadata for a specification based on the provided schema and optional configuration.
+*
+* @param schema - The schema that the specification is expected to conform to.
+* @param config - Optional metadata configuration to extract and normalize.
+* @returns The normalized specification metadata.
+*/
+function resolveMeta(schema, config) {
+	const extractedSchema = (0, _power_plant_schema.isSchemaOf)(schema) ? schema : schema ?? { schema: {} };
+	const meta = {};
+	meta.name = resolveMetaName(extractedSchema.schema, meta, config?.name);
+	meta.version = resolveMetaVersion(extractedSchema?.schema, meta, config?.version);
+	meta.title = resolveMetaTitle(extractedSchema?.schema, meta, config?.title);
+	meta.links = resolveMetaLinks(extractedSchema?.schema, meta, config?.links);
+	if (config?.deprecated) meta.deprecated = config?.deprecated;
+	if (config?.usage) meta.usage = config?.usage;
+	if (config?.tags) meta.tags = config?.tags;
+	return meta;
+}
+
+//#endregion
+exports.formatMetaVersion = formatMetaVersion;
+exports.resolveMeta = resolveMeta;
+exports.resolveMetaDescription = resolveMetaDescription;
+exports.resolveMetaExample = resolveMetaExample;
+exports.resolveMetaId = resolveMetaId;
+exports.resolveMetaLinks = resolveMetaLinks;
+exports.resolveMetaName = resolveMetaName;
+exports.resolveMetaTitle = resolveMetaTitle;
+exports.resolveMetaVersion = resolveMetaVersion;