varlock 0.0.7 → 0.0.9

package/dist/env-KH4bPru7.d.ts

@@ -0,0 +1,356 @@
+import { ParsedEnvSpecDecorator, ParsedEnvSpecFile, ParsedEnvSpecStaticValue, ParsedEnvSpecFunctionCall } from '@env-spec/parser';
+import { FallbackIfUnknown } from '@env-spec/utils/type-utils';
+
+declare class VarlockError extends Error {
+    readonly more?: {
+        tip?: string | Array<string>;
+        err?: Error;
+        isWarning?: boolean;
+        /** machine-friendly error code if needed for anything else */
+        code?: string;
+        /** free-form additional metadata */
+        extraMetadata?: Record<string, any>;
+    } | undefined;
+    originalError?: Error;
+    get isUnexpected(): boolean;
+    get type(): string;
+    static defaultIcon: string;
+    icon: string;
+    _isWarning: boolean;
+    constructor(errOrMessage: string | Error, more?: {
+        tip?: string | Array<string>;
+        err?: Error;
+        isWarning?: boolean;
+        /** machine-friendly error code if needed for anything else */
+        code?: string;
+        /** free-form additional metadata */
+        extraMetadata?: Record<string, any>;
+    } | undefined);
+    get tip(): string | undefined;
+    get code(): string | undefined;
+    get extraMetadata(): Record<string, any> | undefined;
+    set isWarning(w: boolean);
+    get isWarning(): boolean;
+    toJSON(): {
+        isWarning?: true | undefined;
+        tip?: string | undefined;
+        icon: string;
+        type: string;
+        name: string;
+        message: string;
+        isUnexpected: boolean;
+    };
+}
+declare class ConfigLoadError extends VarlockError {
+    readonly cleanedStack: Array<string>;
+    constructor(err: Error);
+    toJSON(): {
+        cleanedStack: string[];
+        isWarning?: true | undefined;
+        tip?: string | undefined;
+        icon: string;
+        type: string;
+        name: string;
+        message: string;
+        isUnexpected: boolean;
+    };
+}
+declare class SchemaError extends VarlockError {
+    static defaultIcon: string;
+}
+declare class ValidationError extends VarlockError {
+    static defaultIcon: string;
+}
+declare class CoercionError extends VarlockError {
+    static defaultIcon: string;
+}
+declare class ResolutionError extends VarlockError {
+    static defaultIcon: string;
+    protected _retryable?: boolean;
+    set retryable(val: boolean);
+    get retryable(): boolean;
+}
+
+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;
+    /** optional description of the type itself */
+    typeDescription?: string;
+    /** icon see https://icones.js.org for available options
+     * @example mdi:aws
+     * */
+    icon?: string;
+    /** coerce function - should take in any value and return a value of the correct type if possible */
+    coerce?: (value: any) => CoerceReturnType | CoercionError | undefined;
+    /**
+     * validate function - we can assume that coercion has already succeded, or this will not be called
+     * - 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>);
+};
+/**
+ * holds a specific instance of a data type, along with specific settings which affect validation/coercion etc
+ */
+declare class EnvGraphDataType {
+    private def;
+    /** reference back to the factory function, which we can use like a constructor to check the type of the instance */
+    private factory;
+    constructor(def: EnvGraphDataTypeDef<any, any>, 
+    /** reference back to the factory function, which we can use like a constructor to check the type of the instance */
+    factory: any);
+    get name(): string;
+    get icon(): string | undefined;
+    /** @internal */
+    get _rawDef(): EnvGraphDataTypeDef<any, any>;
+    coerce(val: any): any;
+    validate(val: any): true | void | Error | Error[];
+}
+declare function createEnvGraphDataType<TsType, InstanceSettingsArgs extends Array<any>>(dataTypeDef: EnvGraphDataTypeDef<TsType> | ((...args: InstanceSettingsArgs) => EnvGraphDataTypeDef<TsType>)): {
+    (...usageOpts: InstanceSettingsArgs): EnvGraphDataType;
+    _isEnvGraphDataTypeFactory: boolean;
+    dataTypeName: string;
+};
+type EnvGraphDataTypeFactory = ReturnType<typeof createEnvGraphDataType>;
+
+declare const DATA_SOURCE_TYPES: Readonly<{
+    schema: {
+        fileSuffixes: string[];
+        precedence: number;
+    };
+    example: {
+        fileSuffixes: string[];
+        precedence: number;
+    };
+    defaults: {
+        fileSuffixes: string[];
+        precedence: number;
+    };
+    values: {
+        fileSuffixes: Array<string>;
+        precedence: number;
+    };
+    overrides: {
+        fileSuffixes: string[];
+        precedence: number;
+    };
+}>;
+type DataSourceType = keyof typeof DATA_SOURCE_TYPES;
+declare abstract class EnvGraphDataSource {
+    static DATA_SOURCE_TYPES: Readonly<{
+        schema: {
+            fileSuffixes: string[];
+            precedence: number;
+        };
+        example: {
+            fileSuffixes: string[];
+            precedence: number;
+        };
+        defaults: {
+            fileSuffixes: string[];
+            precedence: number;
+        };
+        values: {
+            fileSuffixes: Array<string>;
+            precedence: number;
+        };
+        overrides: {
+            fileSuffixes: string[];
+            precedence: number;
+        };
+    }>;
+    graph?: EnvGraph;
+    abstract typeLabel: string;
+    type: DataSourceType;
+    applyForEnv?: string;
+    disabled?: boolean;
+    ignoreNewDefs: boolean;
+    abstract get label(): string;
+    /** an error encountered while loading/parsing the data source */
+    loadingError?: Error;
+    get isValid(): boolean;
+    configItemDefs: Record<string, ConfigItemDef>;
+    decorators: Record<string, ParsedEnvSpecDecorator>;
+    getStaticValues(): Record<string, string>;
+}
+declare class ProcessEnvDataSource extends EnvGraphDataSource {
+    type: "overrides";
+    typeLabel: string;
+    label: string;
+    ignoreNewDefs: boolean;
+    static processEnvValues: Record<string, string | undefined> | undefined;
+    constructor();
+}
+declare abstract class FileBasedDataSource extends EnvGraphDataSource {
+    isGitIgnored?: boolean;
+    fullPath: string;
+    fileName: string;
+    rawContents?: string;
+    get typeLabel(): string;
+    get label(): string;
+    static format: string;
+    static validFileExtensions: Array<string>;
+    get validFileExtensions(): string[];
+    constructor(fullPath: string, opts?: {
+        overrideContents?: string;
+        overrideGitIgnored?: boolean;
+    });
+    finishInit(): Promise<void>;
+    abstract _parseContents(): Promise<void>;
+}
+declare class DotEnvFileDataSource extends FileBasedDataSource {
+    static format: string;
+    static validFileExtensions: never[];
+    parsedFile?: ParsedEnvSpecFile;
+    private convertParserValueToResolvers;
+    _parseContents(): Promise<void>;
+}
+
+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;
+    inferredType?: string;
+    _schemaErrors: Array<SchemaError>;
+    private _depsObj;
+    get childResolvers(): Array<Resolver>;
+    get schemaErrors(): 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>;
+    protected addDep(key: string): void;
+    protected abstract _resolve(): Promise<ResolvedValue>;
+    resolve(): Promise<ResolvedValue>;
+    protected getDepValue(key: string): ResolvedValue;
+}
+type ResolverChildClass<ChildClass extends Resolver = Resolver> = ({
+    new (...args: Array<any>): ChildClass;
+} & typeof Resolver);
+
+type ConfigItemDef = {
+    description?: string;
+    resolver?: Resolver;
+    decorators?: Record<string, ParsedEnvSpecDecorator>;
+};
+type ConfigItemDefAndSource = {
+    itemDef: ConfigItemDef;
+    source: EnvGraphDataSource;
+};
+declare class ConfigItem {
+    #private;
+    constructor(_envGraph: EnvGraph, _key: string);
+    get envGraph(): EnvGraph;
+    get key(): string;
+    defs: Array<ConfigItemDefAndSource>;
+    addDef(itemDef: ConfigItemDef, source: EnvGraphDataSource): void;
+    get description(): string | undefined;
+    get icon(): string | undefined;
+    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;
+    dataType?: EnvGraphDataType;
+    schemaErrors: Array<SchemaError>;
+    get resolverSchemaErrors(): SchemaError[];
+    process(): Promise<void>;
+    get isRequired(): any;
+    get isSensitive(): any;
+    get errors(): (SchemaError | ValidationError | CoercionError | ResolutionError)[];
+    get validationState(): 'warn' | 'error' | 'valid';
+    /** resolved value _before coercion_ */
+    resolvedRawValue?: ResolvedValue;
+    isResolved: boolean;
+    /** resolved value after coercion */
+    resolvedValue?: ResolvedValue;
+    isValidated: boolean;
+    resolutionError?: ResolutionError;
+    coercionError?: CoercionError;
+    validationErrors?: Array<ValidationError>;
+    get isCoerced(): boolean;
+    resolve(): Promise<void>;
+    get isValid(): boolean;
+}
+
+type GraphNodeId = string;
+type GraphAdjacencyList = Record<GraphNodeId, Array<GraphNodeId>>;
+
+type SerializedEnvGraph = {
+    basePath?: string;
+    sources: Array<{
+        label: string;
+        enabled: boolean;
+        path?: string;
+    }>;
+    settings: {
+        redactLogs?: boolean;
+        preventLeaks?: boolean;
+    };
+    config: Record<string, {
+        value: any;
+        isSensitive: boolean;
+    }>;
+};
+/** container of the overall graph and current resolution attempt / values */
+declare class EnvGraph {
+    basePath?: string;
+    /** array of data sources */
+    dataSources: Array<EnvGraphDataSource>;
+    finalOverridesDataSource?: EnvGraphDataSource;
+    /** config item key of env flag (toggles env-specific data sources enabled) */
+    envFlagKey?: string;
+    /** current value of the environment flag */
+    envFlagValue?: string;
+    configSchema: Record<string, ConfigItem>;
+    addDataSource(dataSource: EnvGraphDataSource): void;
+    get schemaDataSource(): EnvGraphDataSource | undefined;
+    get sortedDataSources(): EnvGraphDataSource[];
+    registeredResolverFunctions: Record<string, ResolverChildClass>;
+    registerResolver(resolverClass: ResolverChildClass): void;
+    dataTypesRegistry: Record<string, EnvGraphDataTypeFactory>;
+    registerDataType(factory: EnvGraphDataTypeFactory): void;
+    constructor();
+    finishLoad(): Promise<void>;
+    get graphAdjacencyList(): GraphAdjacencyList;
+    resolveEnvValues(): Promise<void>;
+    getResolvedEnvObject(): Record<string, any>;
+    getSerializedGraph(): SerializedEnvGraph;
+    get isInvalid(): boolean;
+    generateTypes(lang: string, outputPath: string): Promise<void>;
+    getRootDecoratorValue(decoratorName: string): any;
+}
+
+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 { ConfigLoadError as C, DotEnvFileDataSource as D, EnvGraph as E, ProcessEnvDataSource as P, 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 };

package/dist/index.d.ts

@@ -1,12 +1,46 @@
-export { E as ENV, S as SerializedEnvGraph } from './env-k8iRuXIH.js';
+import { E as EnvGraph, D as DotEnvFileDataSource, P as ProcessEnvDataSource, C as ConfigLoadError, S as SchemaError, V as ValidationError, a as CoercionError, R as ResolutionError, i as initVarlockEnv } from './env-KH4bPru7.js';
+export { c as ENV, b as SerializedEnvGraph } from './env-KH4bPru7.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';
+
+declare function loadEnvGraph(opts?: {
+    basePath?: string;
+    relativePaths?: Array<string>;
+    checkGitIgnored?: boolean;
+    excludeDirs?: Array<string>;
+    currentEnvFallback?: string;
+    afterInit?: (graph: EnvGraph) => Promise<void>;
+}): Promise<EnvGraph>;
+
+declare function checkForConfigErrors(envGraph: EnvGraph, opts?: {
+    showAll?: boolean;
+}): void;
+
+declare function loadVarlockEnvGraph(opts?: {
+    currentEnvFallback?: string;
+}): Promise<EnvGraph>;
 
 declare function load(): Promise<void>;
 declare function getBuildTimeReplacements(opts?: {
     objectKey?: string;
     includeSensitive?: boolean;
 }): Record<string, string>;
+declare const internal: {
+    EnvGraph: typeof EnvGraph;
+    DotEnvFileDataSource: typeof DotEnvFileDataSource;
+    ProcessEnvDataSource: typeof ProcessEnvDataSource;
+    loadEnvGraph: typeof loadEnvGraph;
+    ConfigLoadError: typeof ConfigLoadError;
+    SchemaError: typeof SchemaError;
+    ValidationError: typeof ValidationError;
+    CoercionError: typeof CoercionError;
+    ResolutionError: typeof ResolutionError;
+    loadVarlockEnvGraph: typeof loadVarlockEnvGraph;
+    checkForConfigErrors: typeof checkForConfigErrors;
+    initVarlockEnv: typeof initVarlockEnv;
+};
 
-export { getBuildTimeReplacements, load };
+export { getBuildTimeReplacements, internal, load };

package/dist/index.js

@@ -1,14 +1,11 @@
-import { checkForConfigErrors } from './chunk-ZDGB2ZFV.js';
-import { loadVarlockEnvGraph } from './chunk-WOHPERDH.js';
-import './chunk-2H7TDBLD.js';
-import './chunk-LHTLO65N.js';
-import './chunk-QDGAWJPB.js';
-import './chunk-LJKKUJMC.js';
-export { patchGlobalConsole } from './chunk-HQ3K6KKC.js';
-export { patchGlobalResponse } from './chunk-2AA6IZBK.js';
-export { patchGlobalServerResponse } from './chunk-67DF2S4X.js';
-import { initVarlockEnv } from './chunk-7NCUE6IU.js';
-export { ENV } from './chunk-7NCUE6IU.js';
+import { checkForConfigErrors } from './chunk-PB7RWVE6.js';
+import { loadVarlockEnvGraph } from './chunk-ZUG7BEY5.js';
+import { ResolutionError, CoercionError, ValidationError, SchemaError, ConfigLoadError, loadEnvGraph, ProcessEnvDataSource, DotEnvFileDataSource, EnvGraph } from './chunk-ZW2T4C6A.js';
+export { patchGlobalConsole } from './chunk-CYYLAV42.js';
+export { patchGlobalResponse } from './chunk-ELJZUQX3.js';
+export { patchGlobalServerResponse } from './chunk-FLO6F7B6.js';
+import { initVarlockEnv } from './chunk-2CM4YUFY.js';
+export { ENV } from './chunk-2CM4YUFY.js';
 import './chunk-FGMXIEFA.js';
 import { __name } from './chunk-XN24GZXQ.js';
 
@@ -34,7 +31,25 @@ function getBuildTimeReplacements(opts) {
   return replacements;
 }
 __name(getBuildTimeReplacements, "getBuildTimeReplacements");
+var internal = {
+  // Core classes
+  EnvGraph,
+  DotEnvFileDataSource,
+  ProcessEnvDataSource,
+  // Loader function
+  loadEnvGraph,
+  // Error classes
+  ConfigLoadError,
+  SchemaError,
+  ValidationError,
+  CoercionError,
+  ResolutionError,
+  // Varlock-specific utilities
+  loadVarlockEnvGraph,
+  checkForConfigErrors,
+  initVarlockEnv
+};
 
-export { getBuildTimeReplacements, load };
+export { getBuildTimeReplacements, internal, load };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAOA,eAAsB,IAAA,GAAO;AAE3B,EAAA,MAAM,QAAA,GAAW,MAAM,mBAAA,EAAoB;AAC3C,EAAA,MAAM,SAAS,gBAAA,EAAiB;AAChC,EAAA,oBAAA,CAAqB,QAAQ,CAAA;AAG7B,EAAA,OAAA,CAAQ,IAAI,aAAA,GAAgB,IAAA,CAAK,SAAA,CAAU,QAAA,CAAS,oBAAoB,CAAA;AACxE,EAAA,cAAA,EAAe;AAEjB;AAVsB,MAAA,CAAA,IAAA,EAAA,MAAA,CAAA;AAaf,SAAS,yBAAyB,IAAA,EAGtC;AACD,EAAA,IAAI,CAAC,OAAA,CAAQ,GAAA,CAAI,aAAA,SAAsB,EAAC;AACxC,EAAA,MAAM,OAAA,GAAU,IAAA,CAAK,KAAA,CAAM,OAAA,CAAQ,IAAI,aAAa,CAAA;AACpD,EAAA,MAAM,eAAe,EAAC;AACtB,EAAA,KAAA,MAAW,GAAA,IAAO,QAAQ,MAAA,EAAQ;AAChC,IAAA,MAAM,QAAA,GAAW,OAAA,CAAQ,MAAA,CAAO,GAAG,CAAA;AACnC,IAAA,MAAM,WAAA,GAAc,CAAC,QAAA,CAAS,WAAA,IAAe,IAAA,EAAM,gBAAA;AACnD,IAAA,IAAI,CAAC,WAAA,EAAa;AAClB,IAAA,YAAA,CAAa,CAAA,EAAG,IAAA,EAAM,SAAA,IAAa,KAAK,IAAI,GAAG,CAAA,CAAE,CAAA,GAAI,IAAA,CAAK,SAAA,CAAU,OAAA,CAAQ,MAAA,CAAO,GAAG,EAAE,KAAK,CAAA;AAAA,EAC/F;AACA,EAAA,OAAO,YAAA;AACT;AAdgB,MAAA,CAAA,wBAAA,EAAA,0BAAA,CAAA","file":"index.js","sourcesContent":["import { type SerializedEnvGraph } from './serialized-env-graph';\nexport { type SerializedEnvGraph };\n\nimport { checkForConfigErrors } from './cli/helpers/error-checks';\nimport { loadVarlockEnvGraph } from './lib/load-graph';\nimport { initVarlockEnv } from './runtime/env';\n\nexport async function load() {\n  // TODO: add some options\n  const envGraph = await loadVarlockEnvGraph();\n  await envGraph.resolveEnvValues();\n  checkForConfigErrors(envGraph);\n\n  // loadFromSerializedGraph(envGraph.getSerializedGraph());\n  process.env.__VARLOCK_ENV = JSON.stringify(envGraph.getSerializedGraph());\n  initVarlockEnv();\n  // TODO: return resolved env and schema / meta info\n}\n\n\nexport function getBuildTimeReplacements(opts?: {\n  objectKey?: string,\n  includeSensitive?: boolean,\n}) {\n  if (!process.env.__VARLOCK_ENV) return {};\n  const envInfo = JSON.parse(process.env.__VARLOCK_ENV) as SerializedEnvGraph;\n  const replacements = {} as Record<string, string>;\n  for (const key in envInfo.config) {\n    const itemInfo = envInfo.config[key];\n    const replaceItem = !itemInfo.isSensitive || opts?.includeSensitive;\n    if (!replaceItem) continue;\n    replacements[`${opts?.objectKey || 'ENV'}.${key}`] = JSON.stringify(envInfo.config[key].value);\n  }\n  return replacements;\n}\n\nexport { patchGlobalConsole } from './runtime/patch-console';\nexport { patchGlobalServerResponse } from './runtime/patch-server-response';\nexport { patchGlobalResponse } from './runtime/patch-response';\nexport { ENV } from './runtime/env';\n"]}
+{"version":3,"sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAkBA,eAAsB,IAAA,GAAO;AAE3B,EAAA,MAAM,QAAA,GAAW,MAAM,mBAAA,EAAoB;AAC3C,EAAA,MAAM,SAAS,gBAAA,EAAiB;AAChC,EAAA,oBAAA,CAAqB,QAAQ,CAAA;AAG7B,EAAA,OAAA,CAAQ,IAAI,aAAA,GAAgB,IAAA,CAAK,SAAA,CAAU,QAAA,CAAS,oBAAoB,CAAA;AACxE,EAAA,cAAA,EAAe;AAEjB;AAVsB,MAAA,CAAA,IAAA,EAAA,MAAA,CAAA;AAaf,SAAS,yBAAyB,IAAA,EAGtC;AACD,EAAA,IAAI,CAAC,OAAA,CAAQ,GAAA,CAAI,aAAA,SAAsB,EAAC;AACxC,EAAA,MAAM,OAAA,GAAU,IAAA,CAAK,KAAA,CAAM,OAAA,CAAQ,IAAI,aAAa,CAAA;AACpD,EAAA,MAAM,eAAe,EAAC;AACtB,EAAA,KAAA,MAAW,GAAA,IAAO,QAAQ,MAAA,EAAQ;AAChC,IAAA,MAAM,QAAA,GAAW,OAAA,CAAQ,MAAA,CAAO,GAAG,CAAA;AACnC,IAAA,MAAM,WAAA,GAAc,CAAC,QAAA,CAAS,WAAA,IAAe,IAAA,EAAM,gBAAA;AACnD,IAAA,IAAI,CAAC,WAAA,EAAa;AAClB,IAAA,YAAA,CAAa,CAAA,EAAG,IAAA,EAAM,SAAA,IAAa,KAAK,IAAI,GAAG,CAAA,CAAE,CAAA,GAAI,IAAA,CAAK,SAAA,CAAU,OAAA,CAAQ,MAAA,CAAO,GAAG,EAAE,KAAK,CAAA;AAAA,EAC/F;AACA,EAAA,OAAO,YAAA;AACT;AAdgB,MAAA,CAAA,wBAAA,EAAA,0BAAA,CAAA;AAiBT,IAAM,QAAA,GAAW;AAAA;AAAA,EAEtB,QAAA;AAAA,EACA,oBAAA;AAAA,EACA,oBAAA;AAAA;AAAA,EAGA,YAAA;AAAA;AAAA,EAGA,eAAA;AAAA,EACA,WAAA;AAAA,EACA,eAAA;AAAA,EACA,aAAA;AAAA,EACA,eAAA;AAAA;AAAA,EAGA,mBAAA;AAAA,EACA,oBAAA;AAAA,EACA;AACF","file":"index.js","sourcesContent":["import { checkForConfigErrors } from './cli/helpers/error-checks';\nimport { loadVarlockEnvGraph } from './lib/load-graph';\nimport { initVarlockEnv } from './runtime/env';\n\n// Import env-graph components for internal API\nimport {\n  EnvGraph,\n  loadEnvGraph,\n  DotEnvFileDataSource,\n  ProcessEnvDataSource,\n  ConfigLoadError,\n  SchemaError,\n  ValidationError,\n  CoercionError,\n  ResolutionError,\n  type SerializedEnvGraph,\n} from '../env-graph';\n\nexport async function load() {\n  // TODO: add some options\n  const envGraph = await loadVarlockEnvGraph();\n  await envGraph.resolveEnvValues();\n  checkForConfigErrors(envGraph);\n\n  // loadFromSerializedGraph(envGraph.getSerializedGraph());\n  process.env.__VARLOCK_ENV = JSON.stringify(envGraph.getSerializedGraph());\n  initVarlockEnv();\n  // TODO: return resolved env and schema / meta info\n}\n\n\nexport function getBuildTimeReplacements(opts?: {\n  objectKey?: string,\n  includeSensitive?: boolean,\n}) {\n  if (!process.env.__VARLOCK_ENV) return {};\n  const envInfo = JSON.parse(process.env.__VARLOCK_ENV) as SerializedEnvGraph;\n  const replacements = {} as Record<string, string>;\n  for (const key in envInfo.config) {\n    const itemInfo = envInfo.config[key];\n    const replaceItem = !itemInfo.isSensitive || opts?.includeSensitive;\n    if (!replaceItem) continue;\n    replacements[`${opts?.objectKey || 'ENV'}.${key}`] = JSON.stringify(envInfo.config[key].value);\n  }\n  return replacements;\n}\n\n// Internal API for direct env graph manipulation\nexport const internal = {\n  // Core classes\n  EnvGraph,\n  DotEnvFileDataSource,\n  ProcessEnvDataSource,\n\n  // Loader function\n  loadEnvGraph,\n\n  // Error classes\n  ConfigLoadError,\n  SchemaError,\n  ValidationError,\n  CoercionError,\n  ResolutionError,\n\n  // Varlock-specific utilities\n  loadVarlockEnvGraph,\n  checkForConfigErrors,\n  initVarlockEnv,\n};\n\nexport { patchGlobalConsole } from './runtime/patch-console';\nexport { patchGlobalServerResponse } from './runtime/patch-server-response';\nexport { patchGlobalResponse } from './runtime/patch-response';\nexport { ENV } from './runtime/env';\nexport type { SerializedEnvGraph };\n"]}

package/dist/init.command-ZRQOE2OK.js

@@ -0,0 +1,9 @@
+export { commandFn, commandSpec } from './chunk-4WMY2EW3.js';
+import './chunk-FYLMYWUF.js';
+import './chunk-33ROL4J5.js';
+import './chunk-ZUG7BEY5.js';
+import './chunk-ZW2T4C6A.js';
+import './chunk-FGMXIEFA.js';
+import './chunk-XN24GZXQ.js';
+//# sourceMappingURL=init.command-ZRQOE2OK.js.map
+//# sourceMappingURL=init.command-ZRQOE2OK.js.map

package/dist/{init.command-NWFSUQWW.js.map → init.command-ZRQOE2OK.js.map}

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

package/dist/load.command-YBN3BW6U.js

@@ -0,0 +1,9 @@
+export { commandFn, commandSpec } from './chunk-4CE75BSX.js';
+import './chunk-33ROL4J5.js';
+import './chunk-PB7RWVE6.js';
+import './chunk-ZUG7BEY5.js';
+import './chunk-ZW2T4C6A.js';
+import './chunk-FGMXIEFA.js';
+import './chunk-XN24GZXQ.js';
+//# sourceMappingURL=load.command-YBN3BW6U.js.map
+//# sourceMappingURL=load.command-YBN3BW6U.js.map

package/dist/{load.command-U3ZEZYEV.js.map → load.command-YBN3BW6U.js.map}

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

package/dist/login.command-F5AWKZKA.js

@@ -0,0 +1,8 @@
+export { commandFn, commandSpec } from './chunk-GWQT5VGW.js';
+import './chunk-FYLMYWUF.js';
+import './chunk-33ROL4J5.js';
+import './chunk-ZW2T4C6A.js';
+import './chunk-FGMXIEFA.js';
+import './chunk-XN24GZXQ.js';
+//# sourceMappingURL=login.command-F5AWKZKA.js.map
+//# sourceMappingURL=login.command-F5AWKZKA.js.map

package/dist/{login.command-SWBJENRF.js.map → login.command-F5AWKZKA.js.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"login.command-SWBJENRF.js"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"login.command-F5AWKZKA.js"}

package/dist/run.command-WWJ6ZE26.js

@@ -0,0 +1,9 @@
+export { commandFn, commandSpec } from './chunk-KCX4NC7Q.js';
+import './chunk-33ROL4J5.js';
+import './chunk-PB7RWVE6.js';
+import './chunk-ZUG7BEY5.js';
+import './chunk-ZW2T4C6A.js';
+import './chunk-FGMXIEFA.js';
+import './chunk-XN24GZXQ.js';
+//# sourceMappingURL=run.command-WWJ6ZE26.js.map
+//# sourceMappingURL=run.command-WWJ6ZE26.js.map

package/dist/{run.command-WNANCLWN.js.map → run.command-WWJ6ZE26.js.map}

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

package/dist/runtime/env.d.ts

@@ -1 +1,3 @@
-export { E as ENV, T as TypedEnvSchema, i as initVarlockEnv, a as redactSensitiveConfig, r as resetRedactionMap, b as revealSensitiveConfig, s as scanForLeaks, v as varlockSettings } from '../env-k8iRuXIH.js';
+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-KH4bPru7.js';
+import '@env-spec/parser';
+import '@env-spec/utils/type-utils';

package/dist/runtime/env.js

@@ -1,4 +1,4 @@
-export { ENV, initVarlockEnv, redactSensitiveConfig, resetRedactionMap, revealSensitiveConfig, scanForLeaks, varlockSettings } from '../chunk-7NCUE6IU.js';
+export { ENV, initVarlockEnv, redactSensitiveConfig, resetRedactionMap, revealSensitiveConfig, scanForLeaks, varlockSettings } from '../chunk-2CM4YUFY.js';
 import '../chunk-FGMXIEFA.js';
 import '../chunk-XN24GZXQ.js';
 //# sourceMappingURL=env.js.map

package/dist/runtime/patch-console.js

@@ -1,5 +1,5 @@
-export { patchGlobalConsole, unpatchGlobalConsole } from '../chunk-HQ3K6KKC.js';
-import '../chunk-7NCUE6IU.js';
+export { patchGlobalConsole, unpatchGlobalConsole } from '../chunk-CYYLAV42.js';
+import '../chunk-2CM4YUFY.js';
 import '../chunk-FGMXIEFA.js';
 import '../chunk-XN24GZXQ.js';
 //# sourceMappingURL=patch-console.js.map

package/dist/runtime/patch-response.js

@@ -1,5 +1,5 @@
-export { patchGlobalResponse } from '../chunk-2AA6IZBK.js';
-import '../chunk-7NCUE6IU.js';
+export { patchGlobalResponse } from '../chunk-ELJZUQX3.js';
+import '../chunk-2CM4YUFY.js';
 import '../chunk-FGMXIEFA.js';
 import '../chunk-XN24GZXQ.js';
 //# sourceMappingURL=patch-response.js.map

package/dist/runtime/patch-server-response.js

@@ -1,5 +1,5 @@
-export { patchGlobalServerResponse } from '../chunk-67DF2S4X.js';
-import '../chunk-7NCUE6IU.js';
+export { patchGlobalServerResponse } from '../chunk-FLO6F7B6.js';
+import '../chunk-2CM4YUFY.js';
 import '../chunk-FGMXIEFA.js';
 import '../chunk-XN24GZXQ.js';
 //# sourceMappingURL=patch-server-response.js.map

package/dist/telemetry.command-IS2JLIZM.js

@@ -0,0 +1,8 @@
+export { commandFn, commandSpec } from './chunk-LS6F7BSZ.js';
+import './chunk-FYLMYWUF.js';
+import './chunk-33ROL4J5.js';
+import './chunk-ZW2T4C6A.js';
+import './chunk-FGMXIEFA.js';
+import './chunk-XN24GZXQ.js';
+//# sourceMappingURL=telemetry.command-IS2JLIZM.js.map
+//# sourceMappingURL=telemetry.command-IS2JLIZM.js.map

package/dist/{telemetry.command-QMUHAB3Z.js.map → telemetry.command-IS2JLIZM.js.map}

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "varlock",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -65,17 +65,17 @@
     }
   },
   "dependencies": {
-    "debug": "^4.3.4",
+    "debug": "^4.4.1",
     "execa": "^9.6.0",
     "which": "^5.0.0",
-    "@env-spec/parser": "^0.0.3"
+    "@env-spec/parser": "^0.0.4"
   },
   "devDependencies": {
     "@clack/core": "^0.5.0",
     "@clack/prompts": "^0.11.0",
-    "@sindresorhus/is": "^7.0.1",
+    "@sindresorhus/is": "^7.0.2",
     "@types/debug": "^4.1.12",
-    "@types/node": "^22.15.32",
+    "@types/node": "^24.2.0",
     "@types/which": "^3.0.4",
     "@yao-pkg/pkg": "^6.6.0",
     "ansis": "^4.1.0",
@@ -87,9 +87,8 @@
     "is-unicode-supported": "^2.1.0",
     "is-wsl": "^3.1.0",
     "outdent": "^0.8.0",
-    "tsup": "^8.2.4",
+    "tsup": "^8.5.0",
     "vitest": "^3.2.4",
-    "@env-spec/env-graph": "0.0.0",
     "@env-spec/utils": "0.0.0"
   },
   "scripts": {

package/dist/chunk-2AA6IZBK.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/runtime/patch-response.ts"],"names":[],"mappings":";;;;AAGO,SAAS,mBAAA,GAAsB;AACpC,EAAA,KAAA,CAAM,uCAA6B,CAAA;AACnC,EAAA,IAAI,CAAE,UAAA,CAAW,QAAA,CAAiB,iBAAA,EAAmB;AACnD,IAAA,KAAA,CAAM,mBAAmB,CAAA;AACzB,IAAA;AAAA,EACF;AACA,EAAA,IAAI,eAAA,CAAgB,iBAAiB,KAAA,EAAO;AAC1C,IAAA,KAAA,CAAM,wBAAwB,CAAA;AAC9B,IAAA;AAAA,EACF;AAEA,EAAA,MAAM,qBAAqB,UAAA,CAAW,QAAA;AACtC,EAAA,UAAA,CAAW,QAAA,GAAW,MAAM,sBAAA,SAA+B,kBAAA,CAAmB;AAAA,IAfhF;AAegF,MAAA,MAAA,CAAA,IAAA,EAAA,wBAAA,CAAA;AAAA;AAAA,IAC5E,OAAO,iBAAA,GAAoB,IAAA;AAAA,IAC3B,WAAA,CAAY,MAAW,IAAA,EAAW;AAChC,MAAA,KAAA,CAAM,2CAAiC,CAAA;AACvC,MAAA,KAAA,CAAM,aAAa,IAAA,EAAM,EAAE,QAAQ,8BAAA,EAAgC,GAAU,IAAI,CAAA;AAAA,IACnF;AAAA,IACA,OAAO,IAAA,CAAK,IAAA,EAAW,IAAA,EAAW;AAChC,MAAA,KAAA,CAAM,oCAA0B,CAAA;AAChC,MAAA,YAAA,CAAa,KAAK,SAAA,CAAU,IAAI,GAAG,EAAE,MAAA,EAAQ,yBAAyB,CAAA;AACtE,MAAA,MAAM,CAAA,GAAI,kBAAA,CAAmB,IAAA,CAAK,IAAA,EAAM,IAAI,CAAA;AAC5C,MAAA,MAAA,CAAO,cAAA,CAAe,CAAA,EAAG,QAAA,CAAS,SAAS,CAAA;AAC3C,MAAA,OAAO,CAAA;AAAA,IACT;AAAA,GACF;AACF;AA1BgB,MAAA,CAAA,mBAAA,EAAA,qBAAA,CAAA","file":"chunk-2AA6IZBK.js","sourcesContent":["import { scanForLeaks, varlockSettings } from './env';\nimport { debug } from './lib/debug';\n\nexport function patchGlobalResponse() {\n  debug('⚡️ PATCHING global Response');\n  if (!(globalThis.Response as any)._patchedByVarlock) {\n    debug('> already patched');\n    return;\n  }\n  if (varlockSettings.preventLeaks === false) {\n    debug('> disabled by settings');\n    return;\n  }\n\n  const _UnpatchedResponse = globalThis.Response;\n  globalThis.Response = class VarlockPatchedResponse extends _UnpatchedResponse {\n    static _patchedByVarlock = true;\n    constructor(body: any, init: any) {\n      debug('⚡️ patched Response constructor');\n      super(scanForLeaks(body, { method: 'patched Response constructor' }) as any, init);\n    }\n    static json(data: any, init: any) {\n      debug('⚡️ patched Response.json');\n      scanForLeaks(JSON.stringify(data), { method: 'patched Response.json' });\n      const r = _UnpatchedResponse.json(data, init);\n      Object.setPrototypeOf(r, Response.prototype);\n      return r;\n    }\n  };\n}\n"]}