varlock 0.0.15 → 0.1.0

package/dist/{env-DLUhFCnC.d.ts → env-graph-eF0B8G0j.d.ts}

@@ -1,6 +1,17 @@
 import { ParsedEnvSpecDecorator, ParsedEnvSpecFile, ParsedEnvSpecStaticValue, ParsedEnvSpecFunctionCall } from '@env-spec/parser';
 import { FallbackIfUnknown } from '@env-spec/utils/type-utils';
+import { Debugger } from 'debug';
 
+type VarlockErrorLocationDetails = {
+    /** file path or url */
+    id: string;
+    /** 1-based line number */
+    lineNumber: number;
+    /** 1-based column number */
+    colNumber: number;
+    /** full line string */
+    lineStr: string;
+};
 declare class VarlockError extends Error {
     readonly more?: {
         tip?: string | Array<string>;
@@ -8,6 +19,7 @@ declare class VarlockError extends Error {
         isWarning?: boolean;
         /** machine-friendly error code if needed for anything else */
         code?: string;
+        location?: VarlockErrorLocationDetails;
         /** free-form additional metadata */
         extraMetadata?: Record<string, any>;
     } | undefined;
@@ -23,10 +35,12 @@ declare class VarlockError extends Error {
         isWarning?: boolean;
         /** machine-friendly error code if needed for anything else */
         code?: string;
+        location?: VarlockErrorLocationDetails;
         /** free-form additional metadata */
         extraMetadata?: Record<string, any>;
     } | undefined);
     get tip(): string | undefined;
+    get location(): VarlockErrorLocationDetails | undefined;
     get code(): string | undefined;
     get extraMetadata(): Record<string, any> | undefined;
     set isWarning(w: boolean);
@@ -71,6 +85,7 @@ declare class ResolutionError extends VarlockError {
     get retryable(): boolean;
 }
 
+type MaybePromise<T> = T | Promise<T>;
 type EnvGraphDataTypeDef<CoerceReturnType, ValidateInputType = FallbackIfUnknown<CoerceReturnType, string>> = {
     /** this will be the name of the type, used to reference it when using it in a schema */
     name: string;
@@ -87,7 +102,14 @@ type EnvGraphDataTypeDef<CoerceReturnType, ValidateInputType = FallbackIfUnknown
      * - if validation passes, should return true
      * - if validation fails, should return a ValidationError or array of errors - or throw an error
      * */
-    validate: (value: ValidateInputType) => (true | undefined | void | Error | Array<Error>);
+    validate: (value: ValidateInputType) => MaybePromise<(true | undefined | void | Error | Array<Error>)>;
+    /** will make items of this type sensitive, unless overridden specifically on that item */
+    sensitive?: boolean;
+    /** adds docs info for these  */
+    docs?: Array<string | {
+        url: string;
+        description: string;
+    }>;
 };
 /**
  * holds a specific instance of a data type, along with specific settings which affect validation/coercion etc
@@ -101,10 +123,15 @@ declare class EnvGraphDataType {
     factory: any);
     get name(): string;
     get icon(): string | undefined;
+    get isSensitive(): boolean | undefined;
+    get docsEntries(): (string | {
+        url: string;
+        description: string;
+    })[] | undefined;
     /** @internal */
     get _rawDef(): EnvGraphDataTypeDef<any, any>;
     coerce(val: any): any;
-    validate(val: any): true | void | Error | Error[];
+    validate(val: any): MaybePromise<true | void | Error | Error[] | undefined>;
 }
 declare function createEnvGraphDataType<TsType, InstanceSettingsArgs extends Array<any>>(dataTypeDef: EnvGraphDataTypeDef<TsType> | ((...args: InstanceSettingsArgs) => EnvGraphDataTypeDef<TsType>)): {
     (...usageOpts: InstanceSettingsArgs): EnvGraphDataType;
@@ -113,29 +140,112 @@ declare function createEnvGraphDataType<TsType, InstanceSettingsArgs extends Arr
 };
 type EnvGraphDataTypeFactory = ReturnType<typeof createEnvGraphDataType>;
 
-type ResolvedValue = undefined | string | number | boolean | RegExp;
-type ResolverFunctionArgs = Array<Resolver | Record<string, Resolver>>;
-declare abstract class Resolver {
-    readonly fnArgs: ResolverFunctionArgs;
-    static fnName?: string;
-    constructor(fnArgs: ResolverFunctionArgs);
-    abstract label: string;
-    abstract icon: string;
+declare abstract class DecoratorInstance {
+    get name(): string;
+    get isFunctionCall(): boolean;
+    _decValueResolver?: Resolver;
+    get decValueResolver(): Resolver | undefined;
+    abstract readonly isRootDecorator: boolean;
+    abstract readonly dataSource: EnvGraphDataSource;
+    abstract readonly parsedDecorator: ParsedEnvSpecDecorator;
+    abstract graph: EnvGraph;
+    _schemaErrors: Array<SchemaError>;
+    get schemaErrors(): SchemaError[];
+    _executionError?: Error;
+    private decoratorDef?;
+    get incompatibleWith(): string[] | undefined;
+    private processed;
+    private processedData;
+    process(): Promise<void>;
+    execute(): Promise<void>;
+    resolvedValue?: any;
+    isResolved: boolean;
+    resolve(): Promise<any>;
+}
+declare class ItemDecoratorInstance extends DecoratorInstance {
+    readonly configItem: ConfigItem;
+    readonly dataSource: EnvGraphDataSource;
+    readonly parsedDecorator: ParsedEnvSpecDecorator;
+    isRootDecorator: boolean;
+    constructor(configItem: ConfigItem, dataSource: EnvGraphDataSource, parsedDecorator: ParsedEnvSpecDecorator);
+    get graph(): EnvGraph;
+}
+declare class RootDecoratorInstance extends DecoratorInstance {
+    readonly dataSource: EnvGraphDataSource;
+    readonly parsedDecorator: ParsedEnvSpecDecorator;
+    isRootDecorator: boolean;
+    constructor(dataSource: EnvGraphDataSource, parsedDecorator: ParsedEnvSpecDecorator);
+    get graph(): EnvGraph;
+}
+type RootDecoratorDef<Processed = any> = {
+    name: string;
+    description?: string;
+    isFunction?: boolean;
+    deprecated?: boolean | string;
+    incompatibleWith?: Array<string>;
+    process?: (decoratorValue: Resolver) => (Processed | Promise<Processed>);
+    execute?: (executeInput: Processed) => void | Promise<void>;
+    useFnArgsResolver?: boolean;
+};
+type ItemDecoratorDef<T = any> = {
+    name: string;
+    incompatibleWith?: Array<string>;
+    isFunction?: boolean;
+    deprecated?: boolean | string;
+    process?: (decoratorValue: Resolver) => T | Promise<T>;
+    execute?: (executeInput: T) => void | Promise<void>;
+    useFnArgsResolver?: boolean;
+};
+
+type ResolvedValue = undefined | string | number | boolean | RegExp | {
+    [key: string]: ResolvedValue;
+} | Array<ResolvedValue>;
+declare class Resolver {
+    readonly arrArgs?: Array<Resolver> | undefined;
+    readonly objArgs?: Record<string, Resolver> | undefined;
+    readonly dataSource?: EnvGraphDataSource | undefined;
+    static def: ResolverDef;
+    constructor(arrArgs?: Array<Resolver> | undefined, objArgs?: Record<string, Resolver> | undefined, dataSource?: EnvGraphDataSource | undefined);
+    static get fnName(): string;
+    get def(): ResolverDef<any>;
+    get fnName(): string;
+    get label(): string | undefined;
+    get icon(): string | undefined;
+    get isStatic(): boolean;
+    get staticValue(): ResolvedValue;
     inferredType?: string;
     _schemaErrors: Array<SchemaError>;
     private _depsObj;
     get childResolvers(): Array<Resolver>;
     get schemaErrors(): Array<SchemaError>;
+    set schemaErrors(v: Array<SchemaError>);
     get depsObj(): Record<string, boolean>;
     get deps(): string[];
-    protected abstract _process(ctx?: any): Promise<void | (() => void)>;
-    private configItem?;
-    process(configItem: ConfigItem): Promise<void>;
+    private parent?;
+    private meta;
+    process(parent?: ConfigItem | DecoratorInstance): void;
     protected addDep(key: string): void;
-    protected abstract _resolve(): Promise<ResolvedValue>;
+    protected getCurrentEnv(): Promise<string | undefined>;
     resolve(): Promise<ResolvedValue>;
+    get envGraph(): EnvGraph | undefined;
     protected getDepValue(key: string): ResolvedValue;
 }
+type ResolverDef<T = any> = {
+    name: string;
+    description?: string;
+    label?: string;
+    icon?: string;
+    inferredType?: string;
+    argsSchema?: {
+        type: 'array' | 'object' | 'mixed';
+        arrayExactLength?: number;
+        arrayMinLength?: number;
+        arrayMaxLength?: number;
+        objKeyMinLength?: number;
+    };
+    process?: (this: Resolver) => T;
+    resolve: (this: Resolver, state: T) => ResolvedValue | Promise<ResolvedValue>;
+};
 type ResolverChildClass<ChildClass extends Resolver = Resolver> = ({
     new (...args: Array<any>): ChildClass;
 } & typeof Resolver);
@@ -207,7 +317,9 @@ declare abstract class EnvGraphDataSource {
     /** environment flag value getter (follows up the parent chain), and checks the graph-level fallback */
     get envFlagValue(): ResolvedValue;
     /** helper to resolve the envFlag value */
-    resolveCurrentEnv(): Promise<ResolvedValue>;
+    resolveCurrentEnv(): Promise<string | number | boolean | RegExp | {
+        [key: string]: ResolvedValue;
+    } | ResolvedValue[] | undefined>;
     /** finish init process for this data source */
     finishInit(): Promise<void>;
     /**
@@ -225,11 +337,17 @@ declare abstract class EnvGraphDataSource {
     /** an error encountered while loading/parsing the data source */
     _loadingError?: Error;
     get loadingError(): Error | undefined;
+    _schemaErrors: Array<SchemaError>;
+    get schemaErrors(): SchemaError[];
+    get resolutionErrors(): Error[];
     get isValid(): boolean;
     configItemDefs: Record<string, ConfigItemDef>;
     decorators: Array<ParsedEnvSpecDecorator>;
     getRootDecorators(decName: string): ParsedEnvSpecDecorator[];
     getRootDecoratorSimpleValue(decName: string): any;
+    rootDecorators: Array<RootDecoratorInstance>;
+    getRootDec(decName: string): RootDecoratorInstance | undefined;
+    getRootDecFns(decName: string): RootDecoratorInstance[];
 }
 declare abstract class FileBasedDataSource extends EnvGraphDataSource {
     isGitIgnored?: boolean;
@@ -237,6 +355,7 @@ declare abstract class FileBasedDataSource extends EnvGraphDataSource {
     fileName: string;
     rawContents?: string;
     get typeLabel(): string;
+    private relativePath;
     get label(): string;
     static format: string;
     static validFileExtensions: Array<string>;
@@ -252,42 +371,48 @@ declare class DotEnvFileDataSource extends FileBasedDataSource {
     static format: string;
     static validFileExtensions: never[];
     parsedFile?: ParsedEnvSpecFile;
-    private convertParserValueToResolvers;
     _parseContents(): Promise<void>;
 }
 
 type ConfigItemDef = {
     description?: string;
+    parsedDecorators?: Array<ParsedEnvSpecDecorator>;
+    parsedValue: ParsedEnvSpecStaticValue | ParsedEnvSpecFunctionCall | undefined;
     resolver?: Resolver;
-    decorators?: Record<string, ParsedEnvSpecDecorator>;
+    decorators?: Array<ItemDecoratorInstance>;
 };
 type ConfigItemDefAndSource = {
     itemDef: ConfigItemDef;
     source: EnvGraphDataSource;
 };
 declare class ConfigItem {
-    #private;
-    constructor(_envGraph: EnvGraph, _key: string);
-    get envGraph(): EnvGraph;
-    get key(): string;
+    readonly envGraph: EnvGraph;
+    readonly key: string;
+    constructor(envGraph: EnvGraph, key: string);
     /**
      * fetch ordered list of definitions for this item, by following up sorted data sources list
      */
     get defs(): ConfigItemDefAndSource[];
     get description(): string | undefined;
-    get icon(): string | undefined;
+    get icon(): any;
     get docsLinks(): {
         url: string;
         description?: string;
     }[];
     get valueResolver(): Resolver | undefined;
-    getDecorator(decoratorName: string): ParsedEnvSpecDecorator | undefined;
-    getDecoratorValueRaw(decoratorName: string): ParsedEnvSpecStaticValue | ParsedEnvSpecFunctionCall | undefined;
-    getDecoratorValueString(decoratorName: string): string | undefined;
+    allDecorators: Array<ItemDecoratorInstance>;
+    effectiveDecorators: Record<string, ItemDecoratorInstance>;
+    effectiveDecoratorFns: Record<string, Array<ItemDecoratorInstance>>;
+    getDec(decoratorName: string): ItemDecoratorInstance;
+    getDecFns(decoratorName: string): ItemDecoratorInstance[];
+    resolveDecorators(): Promise<void>;
     dataType?: EnvGraphDataType;
-    schemaErrors: Array<SchemaError>;
+    _schemaErrors: Array<SchemaError>;
     get resolverSchemaErrors(): SchemaError[];
+    get decoratorSchemaErrors(): SchemaError[];
+    private isProcessed;
     process(): Promise<void>;
+    get dependencyKeys(): string[];
     /**
      * special early resolution helper
      * currently used to resolve the envFlag before everything else has been loaded
@@ -302,7 +427,9 @@ declare class ConfigItem {
     private processRequired;
     get isRequired(): boolean;
     get isRequiredDynamic(): boolean;
-    get isSensitive(): any;
+    _isSensitive: boolean;
+    get isSensitive(): boolean;
+    private processSensitive;
     get errors(): (SchemaError | ValidationError | CoercionError | ResolutionError)[];
     get validationState(): 'warn' | 'error' | 'valid';
     /** resolved value _before coercion_ */
@@ -322,6 +449,52 @@ declare class ConfigItem {
 type GraphNodeId = string;
 type GraphAdjacencyList = Record<GraphNodeId, Array<GraphNodeId>>;
 
+declare class VarlockPlugin {
+    readonly ERRORS: {
+        ValidationError: typeof ValidationError;
+        CoercionError: typeof CoercionError;
+        SchemaError: typeof SchemaError;
+        ResolutionError: typeof ResolutionError;
+    };
+    private _packageJson?;
+    private _name?;
+    get name(): string;
+    set name(val: string);
+    private _version?;
+    get version(): string;
+    set version(val: string);
+    private _icon?;
+    get icon(): string;
+    set icon(val: string);
+    loadingError?: Error;
+    readonly localPath?: string;
+    /** reference to the `@plugin()` decorator instance(s) that installed the plugin  */
+    installDecoratorInstances: Array<DecoratorInstance>;
+    type: 'single-file' | 'package';
+    constructor(opts: {
+        type: 'single-file' | 'package';
+        localPath: string;
+        loadingError?: Error;
+        packageJson?: {
+            name: string;
+            version?: string;
+            description?: string;
+        };
+    });
+    private debugger;
+    get debug(): (...args: Parameters<Debugger>) => void;
+    readonly dataTypes?: Array<Parameters<typeof createEnvGraphDataType>[0]>;
+    registerDataType(dataTypeDef: Parameters<typeof createEnvGraphDataType>[0]): void;
+    readonly rootDecorators?: Array<RootDecoratorDef<any>>;
+    registerRootDecorator<T>(decoratorDef: RootDecoratorDef<T>): void;
+    readonly itemDecorators?: Array<ItemDecoratorDef<any>>;
+    registerItemDecorator<T>(decoratorDef: ItemDecoratorDef<T>): void;
+    readonly resolverFunctions?: Array<ResolverDef<any>>;
+    registerResolverFunction<T>(resolverDef: ResolverDef<T>): void;
+    get pluginFilePath(): string;
+    executePluginModule(): Promise<void>;
+}
+
 type SerializedEnvGraph = {
     basePath?: string;
     sources: Array<{
@@ -358,41 +531,23 @@ declare class EnvGraph {
     registerResolver(resolverClass: ResolverChildClass): void;
     dataTypesRegistry: Record<string, EnvGraphDataTypeFactory>;
     registerDataType(factory: EnvGraphDataTypeFactory): void;
+    itemDecoratorsRegistry: Record<string, ItemDecoratorDef>;
+    registerItemDecorator(decoratorDef: ItemDecoratorDef): void;
+    rootDecoratorsRegistry: Record<string, RootDecoratorDef>;
+    registerRootDecorator(decoratorDef: RootDecoratorDef): void;
     constructor();
     setRootDataSource(source: EnvGraphDataSource): Promise<void>;
     finishLoad(): Promise<void>;
     get graphAdjacencyList(): GraphAdjacencyList;
-    resolveEnvValues(): Promise<void>;
+    resolveEnvValues(keys?: Array<string>): Promise<void>;
     getResolvedEnvObject(): Record<string, any>;
     getSerializedGraph(): SerializedEnvGraph;
     get isInvalid(): boolean;
     generateTypes(lang: string, outputPath: string): Promise<void>;
-    getRootDecoratorValue(decoratorName: string): any;
-    getRootDecorators(decoratorName: string): [EnvGraphDataSource, ParsedEnvSpecDecorator[]][];
-}
-
-declare function resetRedactionMap(graph: SerializedEnvGraph): void;
-/**
- * Redacts senstive config values from any string/array/object/etc
- *
- * NOTE - must be used only after varlock has loaded config
- * */
-declare function redactSensitiveConfig(o: any): any;
-/**
- * utility to unmask a secret/sensitive value when logging to the console
- * currently this only works on a single secret, not objects or aggregated strings
- * */
-declare function revealSensitiveConfig(secretStr: string): string;
-declare function scanForLeaks(toScan: string | ReadableStream | null, meta?: {
-    method?: string;
-    file?: string;
-}): string | ReadableStream<any> | null;
-declare const varlockSettings: Record<string, any>;
-declare function initVarlockEnv(opts?: {
-    allowFail?: boolean;
-}): void;
-interface TypedEnvSchema {
+    getRootDec(decoratorName: string): RootDecoratorInstance | undefined;
+    getRootDecFns(decoratorName: string): RootDecoratorInstance[];
+    /** plugins installed globally in the graph */
+    plugins: Array<VarlockPlugin>;
 }
-declare const ENV: TypedEnvSchema;
 
-export { ConfigLoadError as C, DotEnvFileDataSource as D, EnvGraph as E, ResolutionError as R, SchemaError as S, type TypedEnvSchema as T, ValidationError as V, CoercionError as a, type SerializedEnvGraph as b, ENV as c, redactSensitiveConfig as d, revealSensitiveConfig as e, initVarlockEnv as i, resetRedactionMap as r, scanForLeaks as s, varlockSettings as v };
+export { ConfigLoadError as C, DotEnvFileDataSource as D, EnvGraph as E, Resolver as R, type SerializedEnvGraph as S, VarlockPlugin as V, SchemaError as a, ValidationError as b, CoercionError as c, ResolutionError as d };

package/dist/index.d.ts

@@ -1,10 +1,13 @@
-import { E as EnvGraph, D as DotEnvFileDataSource, C as ConfigLoadError, S as SchemaError, V as ValidationError, a as CoercionError, R as ResolutionError, i as initVarlockEnv } from './env-DLUhFCnC.js';
-export { c as ENV, b as SerializedEnvGraph } from './env-DLUhFCnC.js';
+import { E as EnvGraph, D as DotEnvFileDataSource, C as ConfigLoadError, a as SchemaError, b as ValidationError, c as CoercionError, d as ResolutionError } from './env-graph-eF0B8G0j.js';
+export { S as SerializedEnvGraph } from './env-graph-eF0B8G0j.js';
+import { initVarlockEnv } from './runtime/env.js';
+export { ENV } from './runtime/env.js';
 export { patchGlobalConsole } from './runtime/patch-console.js';
 export { patchGlobalServerResponse } from './runtime/patch-server-response.js';
 export { patchGlobalResponse } from './runtime/patch-response.js';
 import '@env-spec/parser';
 import '@env-spec/utils/type-utils';
+import 'debug';
 
 declare function loadEnvGraph(opts?: {
     basePath?: string;

package/dist/index.js

@@ -1,8 +1,8 @@
+export { patchGlobalResponse } from './chunk-OM3JCP4E.js';
 export { patchGlobalServerResponse } from './chunk-7JMYT62X.js';
-import { loadVarlockEnvGraph, checkForConfigErrors } from './chunk-UPLR6H2O.js';
-import { ResolutionError, CoercionError, ValidationError, SchemaError, ConfigLoadError, loadEnvGraph, DotEnvFileDataSource, EnvGraph } from './chunk-IWQ4BDSW.js';
+import { loadVarlockEnvGraph, checkForConfigErrors } from './chunk-NGDIT6C3.js';
+import { ResolutionError, CoercionError, ValidationError, SchemaError, ConfigLoadError, loadEnvGraph, DotEnvFileDataSource, EnvGraph } from './chunk-MLIGQWID.js';
 export { patchGlobalConsole } from './chunk-C5BEZMSO.js';
-export { patchGlobalResponse } from './chunk-OM3JCP4E.js';
 import { initVarlockEnv } from './chunk-2SPIWTVE.js';
 export { ENV } from './chunk-2SPIWTVE.js';
 import './chunk-FGMXIEFA.js';

package/dist/init.command-ASK74XBV.js

@@ -0,0 +1,8 @@
+export { commandFn, commandSpec } from './chunk-GY623P3W.js';
+import './chunk-DTNPJJH4.js';
+import './chunk-33ROL4J5.js';
+import './chunk-MLIGQWID.js';
+import './chunk-FGMXIEFA.js';
+import './chunk-XN24GZXQ.js';
+//# sourceMappingURL=init.command-ASK74XBV.js.map
+//# sourceMappingURL=init.command-ASK74XBV.js.map

package/dist/{init.command-YZ23U7SF.js.map → init.command-ASK74XBV.js.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"init.command-YZ23U7SF.js"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"init.command-ASK74XBV.js"}

package/dist/lib/exec-sync-varlock.js

@@ -1,4 +1,4 @@
-export { execSyncVarlock } from '../chunk-LBV2UW3I.js';
+export { execSyncVarlock } from '../chunk-QT5E2RY6.js';
 import '../chunk-XN24GZXQ.js';
 //# sourceMappingURL=exec-sync-varlock.js.map
 //# sourceMappingURL=exec-sync-varlock.js.map

package/dist/load.command-VUKBSBEV.js

@@ -0,0 +1,8 @@
+export { commandFn, commandSpec } from './chunk-7L3IF2MK.js';
+import './chunk-33ROL4J5.js';
+import './chunk-NGDIT6C3.js';
+import './chunk-MLIGQWID.js';
+import './chunk-FGMXIEFA.js';
+import './chunk-XN24GZXQ.js';
+//# sourceMappingURL=load.command-VUKBSBEV.js.map
+//# sourceMappingURL=load.command-VUKBSBEV.js.map

package/dist/{load.command-NVMWXLOK.js.map → load.command-VUKBSBEV.js.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"load.command-NVMWXLOK.js"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"load.command-VUKBSBEV.js"}

package/dist/plugin-lib.d.ts

@@ -0,0 +1,9 @@
+import { V as VarlockPlugin } from './env-graph-eF0B8G0j.js';
+export { R as Resolver } from './env-graph-eF0B8G0j.js';
+import '@env-spec/parser';
+import '@env-spec/utils/type-utils';
+import 'debug';
+
+declare global {
+    const plugin: VarlockPlugin;
+}

package/dist/plugin-lib.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=plugin-lib.js.map
+//# sourceMappingURL=plugin-lib.js.map

package/dist/plugin-lib.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"plugin-lib.js"}

package/dist/run.command-XQ64Z2TN.js

@@ -0,0 +1,8 @@
+export { commandFn, commandSpec } from './chunk-MITVWKKH.js';
+import './chunk-33ROL4J5.js';
+import './chunk-NGDIT6C3.js';
+import './chunk-MLIGQWID.js';
+import './chunk-FGMXIEFA.js';
+import './chunk-XN24GZXQ.js';
+//# sourceMappingURL=run.command-XQ64Z2TN.js.map
+//# sourceMappingURL=run.command-XQ64Z2TN.js.map

package/dist/{run.command-CXMAPHO7.js.map → run.command-XQ64Z2TN.js.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"run.command-CXMAPHO7.js"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"run.command-XQ64Z2TN.js"}

package/dist/runtime/env.d.ts

@@ -1,3 +1,30 @@
-export { c as ENV, T as TypedEnvSchema, i as initVarlockEnv, d as redactSensitiveConfig, r as resetRedactionMap, e as revealSensitiveConfig, s as scanForLeaks, v as varlockSettings } from '../env-DLUhFCnC.js';
+import { S as SerializedEnvGraph } from '../env-graph-eF0B8G0j.js';
 import '@env-spec/parser';
 import '@env-spec/utils/type-utils';
+import 'debug';
+
+declare function resetRedactionMap(graph: SerializedEnvGraph): void;
+/**
+ * Redacts senstive config values from any string/array/object/etc
+ *
+ * NOTE - must be used only after varlock has loaded config
+ * */
+declare function redactSensitiveConfig(o: any): any;
+/**
+ * utility to unmask a secret/sensitive value when logging to the console
+ * currently this only works on a single secret, not objects or aggregated strings
+ * */
+declare function revealSensitiveConfig(secretStr: string): string;
+declare function scanForLeaks(toScan: string | ReadableStream | null, meta?: {
+    method?: string;
+    file?: string;
+}): string | ReadableStream<any> | null;
+declare const varlockSettings: Record<string, any>;
+declare function initVarlockEnv(opts?: {
+    allowFail?: boolean;
+}): void;
+interface TypedEnvSchema {
+}
+declare const ENV: TypedEnvSchema;
+
+export { ENV, type TypedEnvSchema, initVarlockEnv, redactSensitiveConfig, resetRedactionMap, revealSensitiveConfig, scanForLeaks, varlockSettings };

package/dist/telemetry.command-HHZVBFC7.js

@@ -0,0 +1,8 @@
+export { commandFn, commandSpec } from './chunk-LIIRL4NK.js';
+import './chunk-DTNPJJH4.js';
+import './chunk-33ROL4J5.js';
+import './chunk-MLIGQWID.js';
+import './chunk-FGMXIEFA.js';
+import './chunk-XN24GZXQ.js';
+//# sourceMappingURL=telemetry.command-HHZVBFC7.js.map
+//# sourceMappingURL=telemetry.command-HHZVBFC7.js.map

package/dist/{telemetry.command-3DVW7H2K.js.map → telemetry.command-HHZVBFC7.js.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"telemetry.command-3DVW7H2K.js"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"telemetry.command-HHZVBFC7.js"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "varlock",
-  "version": "0.0.15",
+  "version": "0.1.0",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -67,33 +67,40 @@
       "ts-src": "./src/config.ts",
       "types": "./dist/dotenv-compat.d.ts",
       "default": "./dist/dotenv-compat.js"
+    },
+    "./plugin-lib": {
+      "ts-src": "./src/plugin-lib.ts",
+      "types": "./dist/plugin-lib.d.ts",
+      "default": "./dist/plugin-lib.js"
     }
   },
   "dependencies": {
-    "debug": "^4.4.1",
+    "debug": "^4.4.3",
     "execa": "^9.6.0",
+    "semver": "^7.7.3",
     "which": "^5.0.0",
-    "@env-spec/parser": "^0.0.6"
+    "@env-spec/parser": "^0.0.7"
   },
   "devDependencies": {
     "@clack/core": "^0.5.0",
     "@clack/prompts": "^0.11.0",
-    "@sindresorhus/is": "^7.0.2",
+    "@sindresorhus/is": "^7.1.1",
     "@types/debug": "^4.1.12",
-    "@types/node": "^24.3.0",
+    "@types/node": "24.9.2",
+    "@types/semver": "^7.7.1",
     "@types/which": "^3.0.4",
-    "@yao-pkg/pkg": "^6.6.0",
-    "ansis": "^4.1.0",
+    "@yao-pkg/pkg": "^6.10.0",
+    "ansis": "^4.2.0",
     "browser-or-node": "^3.0.0",
-    "ci-info": "^4.3.0",
+    "ci-info": "^4.3.1",
     "exit-hook": "^4.0.0",
     "gunshi": "^0.26.3",
-    "is-docker": "^3.0.0",
+    "is-docker": "^4.0.0",
     "is-unicode-supported": "^2.1.0",
     "is-wsl": "^3.1.0",
     "outdent": "^0.8.0",
     "tsup": "^8.5.0",
-    "vitest": "^3.2.4",
+    "vitest": "^4.0.6",
     "@env-spec/utils": "0.0.0"
   },
   "scripts": {