hazo_env 0.1.1 → 0.3.0

package/dist/migrate/progress.d.ts

@@ -0,0 +1,5 @@
+import type { MigrationProgress } from '../types/index.js';
+export declare function writeMigrationProgress(progressDir: string, jobId: string, p: MigrationProgress): void;
+export declare function readMigrationProgress(progressDir: string, jobId: string): MigrationProgress | null;
+export declare function clearMigrationProgress(progressDir: string, jobId: string): void;
+//# sourceMappingURL=progress.d.ts.map

package/dist/migrate/progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress.d.ts","sourceRoot":"","sources":["../../src/migrate/progress.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE3D,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAGrG;AAED,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAQlG;AAED,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAG/E"}

package/dist/migrate/progress.js

@@ -0,0 +1,24 @@
+// hazo_env/src/migrate/progress.ts — Filesystem-backed migration progress store
+import fs from 'node:fs';
+import path from 'node:path';
+export function writeMigrationProgress(progressDir, jobId, p) {
+    fs.mkdirSync(progressDir, { recursive: true });
+    fs.writeFileSync(path.join(progressDir, `${jobId}.json`), JSON.stringify(p), 'utf-8');
+}
+export function readMigrationProgress(progressDir, jobId) {
+    const filePath = path.join(progressDir, `${jobId}.json`);
+    try {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function clearMigrationProgress(progressDir, jobId) {
+    const filePath = path.join(progressDir, `${jobId}.json`);
+    try {
+        fs.unlinkSync(filePath);
+    }
+    catch { /* ignore */ }
+}

package/dist/migrate/run.d.ts

@@ -0,0 +1,3 @@
+import type { MigrationRequest, MigrationResult } from '../types/index.js';
+export declare function runMigration(req: MigrationRequest): Promise<MigrationResult>;
+//# sourceMappingURL=run.d.ts.map

package/dist/migrate/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/migrate/run.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAkC,MAAM,mBAAmB,CAAC;AA0D3G,wBAAsB,YAAY,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,CAkJlF"}

package/dist/migrate/run.js

@@ -0,0 +1,195 @@
+// hazo_env/src/migrate/run.ts — runMigration pipeline
+//
+// PDF scrubbing (Phase C): after each file copy, files.ts invokes hazo_pdf/server mask_pdf
+// for any .pdf file when HAZO_ENV_MASK_KEY is set. hazo_pdf is an optional peer dep of
+// hazo_env — if not installed the copy still completes (scrub silently skipped).
+// See: src/migrate/files.ts scrubPdfFile() and hazo_pdf/src/server/mask.ts
+import { HazoError, optional_import } from 'hazo_core';
+import { resolveConnectConfig } from '../resolve/connect.js';
+import { resolveFilesConfig } from '../resolve/files.js';
+import { resolveTransport } from './transport.js';
+import { takeSnapshot } from './snapshot.js';
+import { copyDb } from './db.js';
+import { copyFiles } from './files.js';
+import { verifyFiles } from './verify.js';
+import { auditMigration } from './audit.js';
+import { writeMigrationProgress } from './progress.js';
+import { getEnvRole } from '../env.server.js';
+function emitProgress(req, p) {
+    req.onProgress?.(p);
+    if (req.jobId && req.progressDir) {
+        writeMigrationProgress(req.progressDir, req.jobId, p);
+    }
+}
+// Resolve the SQLite driver — prefer better-sqlite3 in tests when env var is set
+function getSqliteDriver() {
+    if (process.env['HAZO_ENV_TEST_SQLITE_DRIVER'] === 'better-sqlite3')
+        return 'better-sqlite3';
+    return 'sql.js';
+}
+async function buildScrubHook(toEnv, scrubMode, tgtAdapter) {
+    const maskKey = process.env['HAZO_ENV_MASK_KEY'];
+    const toRole = getEnvRole(toEnv);
+    const shouldScrub = scrubMode !== 'none' && !!maskKey && (toRole === 'test' || toRole === 'staging');
+    if (!shouldScrub)
+        return undefined;
+    const { loadRuleset } = await import('../mask/ruleset.js');
+    const { getTransform } = await import('../mask/registry.js');
+    let ruleset;
+    try {
+        ruleset = await loadRuleset(tgtAdapter);
+    }
+    catch {
+        return undefined;
+    }
+    if (ruleset.length === 0)
+        return undefined;
+    const transformMap = new Map();
+    for (const rule of ruleset) {
+        const fn = await getTransform(rule.transform);
+        if (!fn)
+            continue;
+        if (!transformMap.has(rule.table))
+            transformMap.set(rule.table, new Map());
+        transformMap.get(rule.table).set(rule.column, fn);
+    }
+    return (table, row) => {
+        const colTransforms = transformMap.get(table);
+        if (!colTransforms || colTransforms.size === 0)
+            return row;
+        const result = { ...row };
+        for (const [col, fn] of colTransforms) {
+            if (col in result)
+                result[col] = fn(result[col], col, maskKey);
+        }
+        return result;
+    };
+}
+export async function runMigration(req) {
+    const startMs = Date.now();
+    const warnings = [];
+    const connect = await optional_import('hazo_connect/server');
+    if (!connect) {
+        throw new HazoError({
+            code: 'HAZO_ENV_MISSING_DEPENDENCY',
+            pkg: 'hazo_env',
+            message: 'hazo_connect is required for migration. Install it as a peer dependency.',
+        });
+    }
+    // Step 1: Validate
+    emitProgress(req, { phase: 'validate', message: 'Validating migration request', percent: 0 });
+    if (!req.from || !req.to) {
+        throw new HazoError({ code: 'HAZO_ENV_INVALID_REQUEST', pkg: 'hazo_env', message: 'Migration requires both from and to environments.' });
+    }
+    if (req.from === req.to) {
+        throw new HazoError({ code: 'HAZO_ENV_INVALID_REQUEST', pkg: 'hazo_env', message: `Source and target environments must differ (got "${req.from}" for both).` });
+    }
+    const toRole = getEnvRole(req.to);
+    if (toRole === 'production' && !req.allowProdTarget) {
+        throw new HazoError({
+            code: 'HAZO_ENV_PROD_TARGET_REFUSED',
+            pkg: 'hazo_env',
+            message: `Refusing to migrate to production environment "${req.to}". Pass allowProdTarget:true and a confirmToken to override.`,
+        });
+    }
+    if (toRole === 'production' && req.allowProdTarget && !req.confirmToken) {
+        throw new HazoError({
+            code: 'HAZO_ENV_PROD_TARGET_REFUSED',
+            pkg: 'hazo_env',
+            message: 'Production target requires a confirmToken for safety.',
+        });
+    }
+    const fromDbConfig = resolveConnectConfig({ env: req.from, allowOtherEnv: true });
+    const toDbConfig = resolveConnectConfig({ env: req.to, allowOtherEnv: true });
+    resolveTransport(fromDbConfig, toDbConfig, req.transport);
+    const includeDb = req.include?.db ?? true;
+    const includeFiles = req.include?.files ?? true;
+    const scrubMode = req.scrub ?? 'auto';
+    // Step 2: Snapshot target
+    emitProgress(req, { phase: 'snapshot', message: 'Taking snapshot of target', percent: 5 });
+    const snapshot = takeSnapshot(toDbConfig);
+    // Step 3: Plan (dry-run stops here)
+    emitProgress(req, { phase: 'plan', message: 'Building migration plan', percent: 10 });
+    if (req.dryRun) {
+        return {
+            ok: true,
+            snapshotId: snapshot.snapshotId,
+            db: includeDb ? { tables: 0, rows: 0, scrubbed: 0 } : undefined,
+            files: includeFiles ? { copied: 0, bytes: 0, placeholdered: 0 } : undefined,
+            warnings: ['dry-run: no changes made'],
+            durationMs: Date.now() - startMs,
+        };
+    }
+    // Create adapters
+    function makeAdapter(dbConfig, readOnly = false) {
+        if (dbConfig.type !== 'sqlite' || !dbConfig.sqlite) {
+            throw new HazoError({
+                code: 'HAZO_ENV_NOT_IMPLEMENTED',
+                pkg: 'hazo_env',
+                message: `Migration is only implemented for SQLite databases. Got type "${dbConfig.type}".`,
+            });
+        }
+        return connect.createHazoConnect({
+            type: 'sqlite',
+            sqlite: {
+                database_path: dbConfig.sqlite.database_path,
+                read_only: readOnly,
+                driver: getSqliteDriver(),
+            },
+        });
+    }
+    const srcAdapter = makeAdapter(fromDbConfig, true);
+    const tgtAdapter = makeAdapter(toDbConfig, false);
+    // Step 4: Schema parity (checked inside copyDb)
+    emitProgress(req, { phase: 'schema-check', message: 'Checking schema parity', percent: 15 });
+    let dbResult;
+    let filesResult;
+    // Step 5: DB copy
+    if (includeDb) {
+        emitProgress(req, { phase: 'db', message: 'Copying database tables', percent: 20 });
+        const scrubHook = await buildScrubHook(req.to, scrubMode, tgtAdapter);
+        const result = await copyDb(srcAdapter, tgtAdapter, {
+            tables: req.tables,
+            scrubHook,
+            onProgress: (msg) => emitProgress(req, { phase: 'db', message: msg }),
+        });
+        dbResult = result;
+        emitProgress(req, { phase: 'db', message: `DB copy complete: ${result.tables} tables, ${result.rows} rows`, percent: 70 });
+    }
+    // Step 6: File copy
+    if (includeFiles) {
+        emitProgress(req, { phase: 'files', message: 'Copying files', percent: 72 });
+        const result = await copyFiles({
+            fromEnv: req.from,
+            toEnv: req.to,
+            onProgress: (msg) => emitProgress(req, { phase: 'files', message: msg }),
+        });
+        filesResult = result;
+    }
+    // Step 7: Verify
+    emitProgress(req, { phase: 'verify', message: 'Running post-migration verification', percent: 80 });
+    const dataRoot = resolveFilesConfig().local.basePath;
+    const verifyReport = await verifyFiles(req.to, dataRoot, { hash: 'sample', checkOrphans: true });
+    if (!verifyReport.ok) {
+        warnings.push(`Verification found issues: missing=${verifyReport.missing.length}, sizeMismatch=${verifyReport.sizeMismatch.length}`);
+    }
+    // Step 8: Finalize — audit
+    emitProgress(req, { phase: 'finalize', message: 'Recording audit event', percent: 95 });
+    await auditMigration(tgtAdapter, {
+        from: req.from,
+        to: req.to,
+        scrub: scrubMode,
+        db: dbResult,
+        files: filesResult ? { copied: filesResult.copied, bytes: filesResult.bytes } : undefined,
+        verify: { ok: verifyReport.ok, checked: verifyReport.checked },
+    });
+    emitProgress(req, { phase: 'done', message: 'Migration complete', percent: 100 });
+    return {
+        ok: true,
+        snapshotId: snapshot.snapshotId,
+        db: dbResult,
+        files: filesResult,
+        warnings,
+        durationMs: Date.now() - startMs,
+    };
+}

package/dist/migrate/snapshot.d.ts

@@ -0,0 +1,8 @@
+import type { DbEnvConfig } from '../types/index.js';
+export interface SnapshotResult {
+    snapshotId: string;
+    createdAt: string;
+}
+export declare function takeSnapshot(toConfig: DbEnvConfig): SnapshotResult;
+export declare function restoreSnapshot(toConfig: DbEnvConfig, snapshotId: string): void;
+//# sourceMappingURL=snapshot.d.ts.map

package/dist/migrate/snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../src/migrate/snapshot.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,WAAW,GAAG,cAAc,CAmBlE;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAuB/E"}

package/dist/migrate/snapshot.js

@@ -0,0 +1,48 @@
+// hazo_env/src/migrate/snapshot.ts — SQLite file-copy snapshot
+import fs from 'node:fs';
+import path from 'node:path';
+import { HazoError } from 'hazo_core';
+export function takeSnapshot(toConfig) {
+    if (toConfig.type !== 'sqlite' || !toConfig.sqlite?.database_path) {
+        throw new HazoError({
+            code: 'HAZO_ENV_NOT_IMPLEMENTED',
+            pkg: 'hazo_env',
+            message: 'Snapshot is only supported for SQLite databases.',
+        });
+    }
+    const srcPath = toConfig.sqlite.database_path;
+    if (!fs.existsSync(srcPath)) {
+        // No DB yet — snapshot is a no-op, return a virtual ID
+        return { snapshotId: `no-db:${srcPath}`, createdAt: new Date().toISOString() };
+    }
+    const snapshotDir = path.join(path.dirname(srcPath), 'snapshots');
+    fs.mkdirSync(snapshotDir, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, '-');
+    const snapshotPath = path.join(snapshotDir, `pre-migrate-${ts}.sqlite`);
+    fs.copyFileSync(srcPath, snapshotPath);
+    return { snapshotId: snapshotPath, createdAt: new Date().toISOString() };
+}
+export function restoreSnapshot(toConfig, snapshotId) {
+    if (toConfig.type !== 'sqlite' || !toConfig.sqlite?.database_path) {
+        throw new HazoError({
+            code: 'HAZO_ENV_NOT_IMPLEMENTED',
+            pkg: 'hazo_env',
+            message: 'Restore is only supported for SQLite databases.',
+        });
+    }
+    if (snapshotId.startsWith('no-db:')) {
+        throw new HazoError({
+            code: 'HAZO_ENV_SNAPSHOT_NOT_FOUND',
+            pkg: 'hazo_env',
+            message: 'Cannot restore: snapshot was taken when no database existed.',
+        });
+    }
+    if (!fs.existsSync(snapshotId)) {
+        throw new HazoError({
+            code: 'HAZO_ENV_SNAPSHOT_NOT_FOUND',
+            pkg: 'hazo_env',
+            message: `Snapshot file not found: ${snapshotId}`,
+        });
+    }
+    fs.copyFileSync(snapshotId, toConfig.sqlite.database_path);
+}

package/dist/migrate/transport.d.ts

@@ -0,0 +1,3 @@
+import type { TransportMode, DbEnvConfig } from '../types/index.js';
+export declare function resolveTransport(fromConfig: DbEnvConfig, toConfig: DbEnvConfig, requested?: TransportMode): 'local' | 'api';
+//# sourceMappingURL=transport.d.ts.map

package/dist/migrate/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/migrate/transport.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEpE,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,WAAW,EACvB,QAAQ,EAAE,WAAW,EACrB,SAAS,GAAE,aAAsB,GAChC,OAAO,GAAG,KAAK,CAYjB"}

package/dist/migrate/transport.js

@@ -0,0 +1,17 @@
+// hazo_env/src/migrate/transport.ts — resolve transport mode for a migration
+import { HazoError } from 'hazo_core';
+export function resolveTransport(fromConfig, toConfig, requested = 'auto') {
+    if (requested === 'ssh') {
+        throw new HazoError({
+            code: 'HAZO_ENV_NOT_IMPLEMENTED',
+            pkg: 'hazo_env',
+            message: 'SSH transport is not yet implemented. Use local or api transport.',
+        });
+    }
+    if (requested === 'api')
+        return 'api';
+    // auto: both sqlite → local
+    if (fromConfig.type === 'sqlite' && toConfig.type === 'sqlite')
+        return 'local';
+    return 'api';
+}

package/dist/migrate/verify.d.ts

@@ -0,0 +1,8 @@
+import type { HazoEnv, VerifyReport, HashMode } from '../types/index.js';
+export interface VerifyOptions {
+    hash?: HashMode;
+    samplePct?: number;
+    checkOrphans?: boolean;
+}
+export declare function verifyFiles(env: HazoEnv, dataRoot: string, opts?: VerifyOptions): Promise<VerifyReport>;
+//# sourceMappingURL=verify.d.ts.map

package/dist/migrate/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../src/migrate/verify.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAEzE,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAMD,wBAAsB,WAAW,CAC/B,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,MAAM,EAChB,IAAI,GAAE,aAAkB,GACvB,OAAO,CAAC,YAAY,CAAC,CAgDvB"}

package/dist/migrate/verify.js

@@ -0,0 +1,51 @@
+// hazo_env/src/migrate/verify.ts — post-migration file verification
+import fs from 'node:fs';
+import path from 'node:path';
+function resolveEnvFilesRoot(env, dataRoot) {
+    return path.join(dataRoot, env, 'files');
+}
+export async function verifyFiles(env, dataRoot, opts = {}) {
+    const { checkOrphans = true } = opts;
+    const filesRoot = resolveEnvFilesRoot(env, dataRoot);
+    const missing = [];
+    const sizeMismatch = [];
+    const hashMismatch = [];
+    const orphans = [];
+    let checked = 0;
+    let sentinelOk = true;
+    // Layer 1: check sentinel file (data root exists and is readable)
+    if (!fs.existsSync(filesRoot)) {
+        sentinelOk = false;
+        return { ok: false, checked: 0, missing: [], sizeMismatch: [], hashMismatch: [], orphans: [], sentinelOk: false };
+    }
+    // Layer 2 & 3: walk all files
+    function walkDir(dir, relBase) {
+        if (!fs.existsSync(dir))
+            return [];
+        return fs.readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+            const relPath = path.join(relBase, entry.name);
+            const absPath = path.join(dir, entry.name);
+            if (entry.isDirectory())
+                return walkDir(absPath, relPath);
+            return [relPath];
+        });
+    }
+    const diskFiles = walkDir(filesRoot, '');
+    for (const relPath of diskFiles) {
+        const absPath = path.join(filesRoot, relPath);
+        try {
+            fs.statSync(absPath); // existence + size (stat succeeds = file accessible)
+            checked++;
+        }
+        catch {
+            missing.push(relPath);
+        }
+    }
+    // Layer 4: orphan check — files on disk with no corresponding DB tracking row
+    // In Phase A, hazo_files integration is not wired; just verify directory is readable
+    if (checkOrphans && !fs.existsSync(filesRoot)) {
+        orphans.push(filesRoot);
+    }
+    const ok = missing.length === 0 && sizeMismatch.length === 0 && hashMismatch.length === 0;
+    return { ok, checked, missing, sizeMismatch, hashMismatch, orphans, sentinelOk };
+}

package/dist/types/index.d.ts

@@ -4,6 +4,8 @@ export type HazoEnv = 'dev' | 'test' | 'staging' | 'prod' | string;
 export type HazoEnvRole = 'development' | 'test' | 'staging' | 'production';
 /** The set of valid environment names for this app, from [env] pattern in INI */
 export type EnvPattern = string[];
+/** Mapping of env name → broad role, for config-driven role resolution */
+export type EnvRoleMap = Record<string, HazoEnvRole>;
 /** Hint about where an environment runs */
 export type HostHint = 'local' | 'remote' | 'unknown';
 /** DB configuration for a single environment (from [db.<env>] in INI) */
@@ -34,45 +36,63 @@ export interface EnvDescription {
     app: string;
     dataRoot: string;
     hostHint: HostHint;
+    roles?: EnvRoleMap;
 }
 /** Options for resolveConnectConfig */
 export interface ResolveConnectOptions {
     env?: HazoEnv;
     allowOtherEnv?: boolean;
 }
-/** Describes a requested migration between two environments */
+export type TransportMode = 'auto' | 'local' | 'ssh' | 'api';
+export type ScrubMode = 'auto' | 'none';
+export type HashMode = 'none' | 'sample' | 'full';
+export interface MigrationProgress {
+    phase: 'validate' | 'snapshot' | 'plan' | 'schema-check' | 'db' | 'files' | 'verify' | 'finalize' | 'done';
+    message: string;
+    percent?: number;
+}
 export interface MigrationRequest {
-    fromEnv: HazoEnv;
-    toEnv: HazoEnv;
-    includeFiles?: boolean;
+    from: HazoEnv;
+    to: HazoEnv;
+    include?: {
+        db?: boolean;
+        files?: boolean;
+    };
+    transport?: TransportMode;
+    scrub?: ScrubMode;
+    tables?: '*' | string[];
     dryRun?: boolean;
+    allowProdTarget?: boolean;
+    confirmToken?: string;
+    onProgress?: (p: MigrationProgress) => void;
+    jobId?: string;
+    progressDir?: string;
 }
-/** Result of a completed migration */
 export interface MigrationResult {
-    success: boolean;
-    rowsMigrated?: number;
-    filesMigrated?: number;
+    ok: boolean;
+    snapshotId?: string;
+    db?: {
+        tables: number;
+        rows: number;
+        scrubbed: number;
+    };
+    files?: {
+        copied: number;
+        bytes: number;
+        placeholdered: number;
+    };
+    warnings: string[];
+    durationMs: number;
     error?: string;
 }
-/** Progress event emitted during a migration run */
-export interface MigrationProgress {
-    phase: 'db' | 'files' | 'verify' | 'done';
-    message: string;
-    percent?: number;
-}
-/** Result of a post-migration file verification */
 export interface VerifyReport {
-    passed: boolean;
-    missingFiles: string[];
-    extraFiles: string[];
-    checksumErrors: string[];
-}
-/** A transform rule for scrubbing/masking sensitive fields */
-export interface ScrubTransform {
-    table: string;
-    column: string;
-    /** Transform strategy: replace with fixed value, hash, or nullify */
-    strategy: 'replace' | 'hash' | 'nullify';
-    replacement?: string;
+    ok: boolean;
+    checked: number;
+    missing: string[];
+    sizeMismatch: string[];
+    hashMismatch: string[];
+    orphans: string[];
+    sentinelOk: boolean;
 }
+export type MaskTransform = (value: unknown, key: string, maskKey: string) => unknown;
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAEA,sDAAsD;AACtD,MAAM,MAAM,OAAO,GAAG,KAAK,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC;AAEnE,mCAAmC;AACnC,MAAM,MAAM,WAAW,GAAG,aAAa,GAAG,MAAM,GAAG,SAAS,GAAG,YAAY,CAAC;AAE5E,iFAAiF;AACjF,MAAM,MAAM,UAAU,GAAG,MAAM,EAAE,CAAC;AAElC,2CAA2C;AAC3C,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEtD,yEAAyE;AACzE,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,QAAQ,GAAG,WAAW,CAAC;IAC7B,MAAM,CAAC,EAAE;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC;IACnC,SAAS,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CACnD;AAED,yDAAyD;AACzD,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE;QACL,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;KAC9B,CAAC;CACH;AAED,8BAA8B;AAC9B,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,OAAO,CAAC;IACb,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,UAAU,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC;CACpB;AAED,uCAAuC;AACvC,MAAM,WAAW,qBAAqB;IACpC,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAID,+DAA+D;AAC/D,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,sCAAsC;AACtC,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,oDAAoD;AACpD,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,IAAI,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,mDAAmD;AACnD,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAID,8DAA8D;AAC9D,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,qEAAqE;IACrE,QAAQ,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,CAAC;IACzC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hazo_env",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Canonical environment resolver — typed env names, per-env DB/file/secret config, doctor and CLI for hazo apps",
   "type": "module",
   "main": "./dist/index.js",
@@ -40,8 +40,11 @@
   "peerDependencies": {
     "hazo_core": "^1.1.0",
     "hazo_config": "^2.1.10",
-    "hazo_connect": "^3.4.0",
+    "hazo_connect": "^3.4.1",
     "hazo_files": "^3.0.0",
+    "hazo_secure": "^1.2.0",
+    "hazo_audit": "^2.1.0",
+    "hazo_pdf": "^2.0.0",
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0",
     "next": "^14.0.0 || ^16.0.0"
@@ -53,6 +56,15 @@
     "hazo_files": {
       "optional": true
     },
+    "hazo_secure": {
+      "optional": true
+    },
+    "hazo_audit": {
+      "optional": true
+    },
+    "hazo_pdf": {
+      "optional": true
+    },
     "react": {
       "optional": true
     },
@@ -74,7 +86,7 @@
     "@types/react-dom": "^19.0.0",
     "hazo_core": "^1.1.0",
     "hazo_config": "^2.1.10",
-    "hazo_connect": "^3.4.0",
+    "hazo_connect": "^3.4.1",
     "hazo_files": "^3.0.0",
     "next": "^16.0.10",
     "react": "^19.0.0",