@helios-lang/contract-utils 0.3.21 → 0.3.23

package/src/cli/wallet-file.mjs

@@ -0,0 +1,14 @@
+import { open, unlink } from "node:fs/promises"
+import { windowsAcl } from "./config.mjs"
+export async function writePrivateWallet(path, json) {
+    const file = await open(path, "wx", 0o600)
+    try {
+        if (process.platform === "win32") await windowsAcl(path, false, true)
+        await file.writeFile(json, "utf8")
+    } catch (error) {
+        await file.close()
+        await unlink(path)
+        throw error
+    }
+    await file.close()
+}

package/src/cli/wallet.mjs

@@ -0,0 +1,51 @@
+import { randomBytes } from "node:crypto"
+import { parseArgs } from "node:util"
+import { makeRootPrivateKey } from "@helios-lang/tx-utils"
+import { makeShelleyAddress } from "@helios-lang/ledger"
+
+export function createWallet(network = "preprod") {
+    if (!["preprod", "preview", "mainnet"].includes(network))
+        throw new Error("Network must be preprod, preview, or mainnet")
+    const key = makeRootPrivateKey([...randomBytes(32)])
+    const address = makeShelleyAddress(
+        network === "mainnet",
+        key.deriveSpendingKey().derivePubKey().hash(),
+        key.deriveStakingKey().derivePubKey().hash()
+    )
+    return {
+        network,
+        phrase: key.toPhrase().join(" "),
+        address: address.toBech32()
+    }
+}
+export async function walletCommand(args) {
+    const [command, ...rest] = args
+    if (["--help", "-h", "help"].includes(command)) {
+        console.log(
+            "helios wallet create [--network preprod|preview|mainnet] [--out wallet.json]\nGenerates a 24-word recovery phrase and address offline. Without --out, prints the secret phrase as JSON. --out creates a new owner-only file and never overwrites an existing file."
+        )
+        return
+    }
+    if (command !== "create")
+        throw new Error(
+            "Usage: helios wallet create [--network preprod|preview|mainnet] [--out wallet.json]"
+        )
+    const { values } = parseArgs({
+        args: rest,
+        options: {
+            network: { type: "string", default: "preprod" },
+            out: { type: "string" }
+        }
+    })
+    const wallet = createWallet(values.network)
+    const json = JSON.stringify(wallet, null, 2) + "\n"
+    if (values.out !== undefined) {
+        if (!values.out.trim()) throw new Error("--out requires a file path")
+        // Reuse credential-file ACL protection on Windows, before storing secrets.
+        const { writePrivateWallet } = await import("./wallet-file.mjs")
+        await writePrivateWallet(values.out, json)
+        console.log(
+            `Created ${wallet.network} wallet: ${wallet.address}\nRecovery phrase saved in ${values.out}`
+        )
+    } else console.log(json)
+}

package/src/codegen/LoadedScriptsWriter.js

@@ -9,22 +9,33 @@ import { genTypes } from "./TypeSchema.js"
 
 /**
  * Constructs a LoadedScriptsWriter instance and initializes it be writing the header
+ * @param {import("../index.js").DebuggerContext} [debuggerContext]
  * @returns {LoadedScriptsWriter}
  */
-export function makeLoadedScriptsWriter() {
-    return new LoadedScriptsWriterImpl()
+export function makeLoadedScriptsWriter(debuggerContext) {
+    return new LoadedScriptsWriterImpl(debuggerContext)
 }
 
 /**
  * @implements {LoadedScriptsWriter}
  */
 class LoadedScriptsWriterImpl {
-    constructor() {
+    /** @param {import("../index.js").DebuggerContext} [debuggerContext] */
+    constructor(debuggerContext) {
+        this.debuggerContext = debuggerContext
         this.definition = makeStringWriter()
         this.declaration = makeStringWriter()
         this.combined = makeStringWriter()
 
         this.writeHeaders()
+        if (debuggerContext) {
+            const value = JSON.stringify(debuggerContext)
+            this.definition.write(`export const $debugger = ${value}\n`)
+            this.combined.write(`export const $debugger = ${value}\n`)
+            this.declaration.write(
+                `export declare const $debugger: import("@helios-lang/contract-utils").DebuggerContext\n`
+            )
+        }
     }
 
     /**
@@ -271,6 +282,7 @@ class LoadedScriptsWriterImpl {
      */
     writeModule(m) {
         this.definition.write(`export const ${m.name} = {
+    ${this.debuggerContext ? "$debugger," : ""}
     $name: /** @type {const} */ ("${m.name}"),
     $purpose: /** @type {const} */ ("${m.purpose}"),
     $sourceCode: ${JSON.stringify(m.sourceCode)},
@@ -278,6 +290,7 @@ class LoadedScriptsWriterImpl {
 
         this.declaration.write(
             `export const ${m.name}: {
+    ${this.debuggerContext ? '$debugger: import("@helios-lang/contract-utils").DebuggerContext' : ""}
     $name: "${m.name}"
     $purpose: "${m.purpose}"
     $sourceCode: string
@@ -286,6 +299,7 @@ class LoadedScriptsWriterImpl {
 
         this.combined.write(
             `export const ${m.name} = {
+    ${this.debuggerContext ? "$debugger," : ""}
     $name: "${m.name}" as const,
     $purpose: "${m.purpose}" as const,
     $sourceCode: ${JSON.stringify(m.sourceCode)} as string,
@@ -311,6 +325,7 @@ class LoadedScriptsWriterImpl {
 
         this.definition.write(
             `export const ${v.name} = {
+    ${this.debuggerContext ? "$debugger," : ""}
     $name: /** @type {const} */ ("${v.name}"),
     $purpose: /** @type {const} */ ("${v.purpose}"),
 ${isSome(currentScriptIndex) ? `    $currentScriptIndex: /** @type {const} */ (${currentScriptIndex}),` : ""}
@@ -324,6 +339,7 @@ ${datumTypes ? `    $Datum: (config) => /** @type {Cast<${datumTypes[0]}, ${datu
 
         this.declaration.write(
             `export const ${v.name}: {
+    ${this.debuggerContext ? '$debugger: import("@helios-lang/contract-utils").DebuggerContext' : ""}
     $name: "${v.name}"
     $purpose: "${v.purpose}"
 ${isSome(currentScriptIndex) ? `    $currentScriptIndex: ${currentScriptIndex}` : ""}
@@ -340,6 +356,7 @@ ${datumTypes ? `    $Datum: ConfigurableCast<${datumTypes[0]}, ${datumTypes[1]}>
 
         this.combined.write(
             `export const ${v.name} = {
+    ${this.debuggerContext ? "$debugger," : ""}
     $name: "${v.name}" as const,
     $purpose: "${v.purpose}" as const,
 ${isSome(currentScriptIndex) ? `    $currentScriptIndex: ${currentScriptIndex} as const,` : ""}

package/src/context/ContractContextBuilder.js

@@ -1,3 +1,4 @@
+import { bindDebuggerContexts } from "./debugger.js"
 import { expectDefined } from "@helios-lang/type-utils"
 import { configureCast } from "../cast/Cast.js"
 import { loadCompilerLib } from "../compiler/index.js"
@@ -115,7 +116,7 @@ class ContractContextBuilderImpl {
 
         const cached = contractContextCache.get(key)
 
-        const compiled =
+        let compiled =
             cached ||
             dagCompiler.build(
                 Object.values(this.validators),
@@ -125,6 +126,7 @@ class ContractContextBuilderImpl {
             )
 
         contractContextCache.set(key, compiled)
+        compiled = bindDebuggerContexts(compiled, this.validators, this.modules)
 
         if (props.dumpHashes) {
             for (let name in compiled.validators) {
@@ -136,11 +138,34 @@ class ContractContextBuilderImpl {
          * @type {any}
          */
         const res = {}
+        const contexts = [
+            ...Object.values(this.validators),
+            ...Object.values(this.modules)
+        ]
+            .map((v) => v.$debugger)
+            .filter(Boolean)
+        if (
+            contexts.length &&
+            contexts.every(
+                (c) =>
+                    c?.apiKey === contexts[0]?.apiKey &&
+                    c?.endpoint === contexts[0]?.endpoint
+            )
+        )
+            res.$debugger = contexts[0]
 
         for (let name in this.modules) {
             const mod = this.modules[name]
 
             res[name] = {
+                ...(this.validators[name]?.$debugger ||
+                this.modules[name]?.$debugger
+                    ? {
+                          $debugger:
+                              this.validators[name]?.$debugger ??
+                              this.modules[name]?.$debugger
+                      }
+                    : {}),
                 ...Object.fromEntries(
                     Object.entries(mod.$types).map(([typeName, castLike]) => [
                         typeName,
@@ -167,6 +192,14 @@ class ContractContextBuilderImpl {
             const validator = this.validators[name]
 
             res[name] = {
+                ...(this.validators[name]?.$debugger ||
+                this.modules[name]?.$debugger
+                    ? {
+                          $debugger:
+                              this.validators[name]?.$debugger ??
+                              this.modules[name]?.$debugger
+                      }
+                    : {}),
                 ...Object.fromEntries(
                     Object.entries(validator.$types).map(
                         ([typeName, castLike]) => [

package/src/context/debugger.js

@@ -0,0 +1,46 @@
+import { cacheEntryFromJson, cacheEntryToJsonSafe } from "./CacheEntry.js"
+/**
+ * Bind credentials after cache lookup, keeping shared compilation caches credential-free.
+ * @param {import('./CacheEntry.js').CacheEntry} compiled
+ * @param {Record<string, import('../index.js').LoadedValidator>} validators
+ * @param {Record<string, import('../index.js').LoadedModule>} modules
+ * @returns {import('./CacheEntry.js').CacheEntry}
+ */
+export function bindDebuggerContexts(compiled, validators, modules) {
+    if (
+        ![...Object.values(validators), ...Object.values(modules)].some(
+            (v) => v.$debugger
+        )
+    )
+        return compiled
+    const result = cacheEntryFromJson(cacheEntryToJsonSafe(compiled))
+    for (const [name, hash] of Object.entries(result.validators)) {
+        const context = validators[name]?.$debugger
+        if (context) {
+            const hashContext = /** @type {any} */ (hash.context)
+            attach(hashContext.program, context)
+            Object.defineProperty(hashContext, "$debugger", {
+                value: context,
+                enumerable: false
+            })
+        }
+    }
+    for (const [name, program] of Object.entries(result.userFuncs)) {
+        const moduleName = name.split("::")[0]
+        const context =
+            validators[moduleName]?.$debugger ?? modules[moduleName]?.$debugger
+        if (context) attach(program, context)
+    }
+    return result
+}
+/**
+ * @param {import('@helios-lang/uplc').UplcProgram} program
+ * @param {import('../index.js').DebuggerContext} context
+ */
+function attach(program, context) {
+    Object.defineProperty(program, "$debugger", {
+        value: context,
+        enumerable: false
+    })
+    if (program.alt) attach(program.alt, context)
+}

package/src/helios.mjs

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises"
+const [command, ...args] = process.argv.slice(2)
+try {
+    if (command === "compile") {
+        const { compile } = await import("./cli/compile.js")
+        await compile(
+            args.map((arg) => (["--help", "-h"].includes(arg) ? "help" : arg))
+        )
+    } else if (command === "wallet") {
+        const { walletCommand } = await import("./cli/wallet.mjs")
+        await walletCommand(args)
+    } else if (command === "login") {
+        if (args.some((arg) => arg !== "--no-browser"))
+            throw new Error("Usage: helios login [--no-browser]")
+        const { login } = await import("./cli/login.mjs")
+        const abort = new AbortController()
+        const cancel = () => abort.abort(new Error("Login cancelled"))
+        process.once("SIGINT", cancel)
+        process.once("SIGTERM", cancel)
+        try {
+            await login({
+                noBrowser: args.includes("--no-browser"),
+                signal: AbortSignal.any([
+                    abort.signal,
+                    AbortSignal.timeout(600000)
+                ])
+            })
+        } finally {
+            process.removeListener("SIGINT", cancel)
+            process.removeListener("SIGTERM", cancel)
+        }
+    } else if (command === "--version" || command === "-v") {
+        console.log(
+            JSON.parse(
+                await readFile(
+                    new URL("../package.json", import.meta.url),
+                    "utf8"
+                )
+            ).version
+        )
+    } else if (!command || ["--help", "-h", "help"].includes(command)) {
+        console.log(
+            "Helios CLI\n\n  helios compile [options]  Compile contracts (same options as hl2ts)\n  helios login [--no-browser]  Install project API keys through the Console\n  helios wallet create [--network preprod] [--out wallet.json]  Generate a wallet offline\n  helios --version"
+        )
+    } else throw new Error(`Unknown command: ${command}. Run helios --help.`)
+} catch (error) {
+    console.error(error.message)
+    process.exitCode = 1
+}

package/src/hl2ts.js

@@ -1,186 +1,6 @@
 #!/usr/bin/env node
-
-import {
-    existsSync,
-    mkdirSync,
-    promises,
-    readFileSync,
-    writeFileSync
-} from "node:fs"
-import { dirname, join, resolve } from "node:path"
-import { Cli, EnumOpt, StringOpt } from "@helios-lang/cli-utils"
-import { makeLoadedScriptsWriter } from "./codegen/index.js"
-import { loadCompilerLib } from "./compiler/index.js"
-import { typeCheckFiles } from "./compiler/ops.js"
-
-/**
- * @typedef {{
- *   name: string
- *   purpose: string
- *   sourceCode: string
- * }} SourceDetails
- */
-
-/**
- * @typedef {"javascript" | "typescript"} FormatKind
- */
-
-const NAME = "hl2ts"
-
-async function main() {
-    const cli = new Cli(NAME, {
-        minArgs: 0,
-        maxArgs: 0,
-        options: {
-            outDir: new StringOpt({
-                long: "--out-dir",
-                short: "-o",
-                default: () => process.cwd()
-            }),
-            format: new EnumOpt({
-                long: "--format",
-                short: "-f",
-                variants: /** @type {FormatKind[]} */ ([
-                    "javascript",
-                    "typescript"
-                ]),
-                default: () => {
-                    const path = findPackageJson()
-
-                    if (
-                        path &&
-                        existsSync(join(dirname(path), "tsconfig.json"))
-                    ) {
-                        return "typescript"
-                    } else {
-                        return "javascript"
-                    }
-                }
-            })
-        },
-        action: mainInternal
-    })
-
-    await cli.run()
-}
-
-/**
- * @param {string[]} _args
- * @param {{outDir: string, format: FormatKind}} options
- * @returns {Promise<void>}
- */
-async function mainInternal(_args, { outDir, format }) {
-    const lib = loadCompilerLib()
-
-    const filePaths = await listFiles(process.cwd(), ".hl")
-    const files = readFiles(filePaths)
-
-    console.log(`${NAME} using Helios compiler v${lib.version}`)
-    console.log(`  Transpiling ${Object.keys(files).length} inputs:`)
-    filePaths.forEach((p) => console.log(`    ${p}`))
-
-    const { modules, validators } = typeCheckFiles(lib, files, (current, rel) =>
-        resolve(join(dirname(current), rel))
-    )
-
-    const [js, dts, ts] = makeLoadedScriptsWriter()
-        .writeModules(modules)
-        .writeValidators(validators)
-        .finalize()
-
-    if (format == "typescript") {
-        const tsPath = join(outDir, "index.ts")
-
-        writeFileSync(tsPath, ts)
-
-        console.log(`  Output:`)
-        console.log(`    ${tsPath}`)
-    } else {
-        const resolvedOutDir = resolve(outDir)
-
-        mkdirIfNotExists(resolvedOutDir)
-
-        const jsPath = join(resolvedOutDir, "index.js")
-        const dtsPath = join(resolvedOutDir, "index.d.ts")
-
-        writeFileSync(jsPath, js)
-        writeFileSync(dtsPath, dts)
-
-        console.log(`  Output:`)
-        console.log(`    ${jsPath}`)
-        console.log(`    ${dtsPath}`)
-    }
-}
-
-main()
-
-/**
- * @param {string} dir
- * @param {string} ext
- * @returns {Promise<string[]>}
- */
-async function listFiles(dir, ext) {
-    const entries = await promises.readdir(dir, { withFileTypes: true })
-
-    const files = await Promise.all(
-        entries.map((entry) => {
-            const res = resolve(dir, entry.name)
-
-            if (entry.isDirectory()) {
-                if (entry.name.endsWith("node_modules")) {
-                    return []
-                } else {
-                    return listFiles(res, ext)
-                }
-            } else {
-                return res
-            }
-        })
-    )
-
-    return files.flat().filter((name) => name.endsWith(ext))
-}
-
-/**
- * @param {string[]} filePaths
- * @returns {{[path: string]: string}}
- */
-function readFiles(filePaths) {
-    return Object.fromEntries(
-        filePaths.map((f) => {
-            return [f, readFileSync(f).toString()]
-        })
-    )
-}
-
-/**
- * @param {string} fileName
- * @returns {string | undefined}
- */
-function findPackageJson(fileName = "package.json") {
-    let dir = process.cwd()
-
-    let path = join(dir, fileName)
-    let found = existsSync(path)
-
-    while (!found) {
-        dir = dirname(dir)
-        path = join(dir, fileName)
-        found = existsSync(path)
-    }
-
-    if (found) {
-        return path
-    } else {
-        return undefined
-    }
-}
-
-/**
- * @param {string} dir
- */
-function mkdirIfNotExists(dir) {
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true })
-    }
-}
+import { compile } from "./cli/compile.js"
+compile(process.argv.slice(2)).catch((error) => {
+    console.error(error.message)
+    process.exitCode = 1
+})

package/src/index.js

@@ -204,6 +204,7 @@ export { genTypes } from "./codegen/TypeSchema.js"
 
 /**
  * @typedef {{
+ *   $debugger?: DebuggerContext
  *   $name: string
  *   $purpose: "module"
  *   $sourceCode: string
@@ -216,6 +217,7 @@ export { genTypes } from "./codegen/TypeSchema.js"
 /**
  * * Note: `$hashDependencies` doesn't contain the indirect dependencies! It must be kept to a minimum in order to inform in which order the validators must be compiled
  * @typedef {{
+ *   $debugger?: DebuggerContext
  *   $name: string
  *   $sourceCode: string
  *   $dependencies: ReadonlyArray<LoadedModule>
@@ -341,7 +343,7 @@ export { genTypes } from "./codegen/TypeSchema.js"
  *   [K in keyof Vs]: ContractValidatorContexts<Vs[K]>
  * } & {
  *   [K in keyof Ms]: ContractModuleContexts<Ms[K]>
- * }} ContractContext
+ * } & {$debugger?: DebuggerContext}} ContractContext
  */
 
 /**
@@ -386,3 +388,10 @@ export { genTypes } from "./codegen/TypeSchema.js"
  *   fs: FileSystem
  * }} WriteContractContextArtifactsOptions
  */
+
+/**
+ * Metadata carried outside script CBOR/hashes for automatic failed-transaction capture.
+ * @typedef {{projectId: string, name: string, apiKey: string, endpoint: string, sources?: Record<string,string>}} DebuggerContext
+ */
+
+/** @typedef {UplcProgram & {$debugger?: DebuggerContext}} DebuggerUplcProgram */

package/types/artifacts/ChildArtifactWriter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ChildArtifactWriter.d.ts","sourceRoot":"","sources":["../../src/artifacts/ChildArtifactWriter.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;IAaI;;;OAGG;IACH,oBAHW,QAAQ,QACR,MAAM,EAOhB;IArBD;;;OAGG;IACH,iBAFU,QAAQ,CAEZ;IAEN;;;OAGG;IACH,eAFU,MAAM,CAEZ;IAaJ;;OAEG;IACH,iBAFU,OAAO,CAIhB;IAED;;;;;OAKG;IACH,mBALW,MAAM,WACN,WAAW,cACX,OAAO,GACL,mBAAmB,CA0D/B;CACJ;+BArG8B,qBAAqB;8BAIvB,eAAe;iCADZ,mBAAmB"}
+{"version":3,"file":"ChildArtifactWriter.d.ts","sourceRoot":"","sources":["../../src/artifacts/ChildArtifactWriter.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;IAaI;;;OAGG;IACH,oBAHW,QAAQ,QACR,MAAM,EAOhB;IArBD;;;OAGG;IACH,iBAFU,QAAQ,CAEZ;IAEN;;;OAGG;IACH,eAFU,MAAM,CAEZ;IAaJ;;OAEG;IACH,iBAFU,OAAO,CAIhB;IAED;;;;;OAKG;IACH,mBALW,MAAM,WACN,WAAW,cACX,OAAO,GACL,mBAAmB,CA4E/B;CACJ;+BAvH8B,qBAAqB;8BAIvB,eAAe;iCADZ,mBAAmB"}

package/types/artifacts/RootArtifact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RootArtifact.d.ts","sourceRoot":"","sources":["../../src/artifacts/RootArtifact.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;GAGG;AACH,uDAHW,GAAG,WACH,oCAAoC,QAoC9C;0DA1CyJ,aAAa"}
+{"version":3,"file":"RootArtifact.d.ts","sourceRoot":"","sources":["../../src/artifacts/RootArtifact.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;GAGG;AACH,uDAHW,GAAG,WACH,oCAAoC,QA4C9C;0DAlDyJ,aAAa"}

package/types/cli/compile.d.ts

@@ -0,0 +1,9 @@
+/** @param {string[]} args */
+export function compile(args: string[]): Promise<void>;
+export type SourceDetails = {
+    name: string;
+    purpose: string;
+    sourceCode: string;
+};
+export type FormatKind = "javascript" | "typescript";
+//# sourceMappingURL=compile.d.ts.map

package/types/cli/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/cli/compile.js"],"names":[],"mappings":"AA2BA,6BAA6B;AAC7B,8BADY,MAAM,EAAE,iBA8CnB;4BA3DY;IACR,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;CACnB;yBAIS,YAAY,GAAG,YAAY"}

package/types/cli/config.d.mts

@@ -0,0 +1,5 @@
+export function windowsAcl(path: any, directory: any, set?: boolean): Promise<void>;
+export function configPath(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv, home?: string): string;
+export function readConfig(path?: string): Promise<any>;
+export function installProjects(wallet: any, projects: any, endpoint: any, path?: string): Promise<string>;
+//# sourceMappingURL=config.d.mts.map

package/types/cli/config.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.mts","sourceRoot":"","sources":["../../src/cli/config.mjs"],"names":[],"mappings":"AAeA,oFAiCC;AACD,uGAcC;AAqBD,wDAaC;AACD,2GA2DC"}

package/types/cli/project.d.mts

@@ -0,0 +1,11 @@
+export function resolveProject(name: any, { read, fetchImpl }?: {
+    read?: typeof readConfig | undefined;
+    fetchImpl?: typeof fetch | undefined;
+}): Promise<{
+    projectId: any;
+    name: any;
+    apiKey: any;
+    endpoint: string;
+}>;
+import { readConfig } from "./config.mjs";
+//# sourceMappingURL=project.d.mts.map

package/types/cli/project.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.mts","sourceRoot":"","sources":["../../src/cli/project.mjs"],"names":[],"mappings":"AACA;;;;;;;;GAiEC;2BAlE0B,cAAc"}

package/types/codegen/LoadedScriptsWriter.d.ts

@@ -4,9 +4,10 @@
  */
 /**
  * Constructs a LoadedScriptsWriter instance and initializes it be writing the header
+ * @param {import("../index.js").DebuggerContext} [debuggerContext]
  * @returns {LoadedScriptsWriter}
  */
-export function makeLoadedScriptsWriter(): LoadedScriptsWriter;
+export function makeLoadedScriptsWriter(debuggerContext?: import("../index.js").DebuggerContext): LoadedScriptsWriter;
 /**
  * @param {TypeCheckedUserFunc} props
  * @param {boolean} unsafe

package/types/codegen/LoadedScriptsWriter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LoadedScriptsWriter.d.ts","sourceRoot":"","sources":["../../src/codegen/LoadedScriptsWriter.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;GAGG;AACH,2CAFa,mBAAmB,CAI/B;AAsXD;;;;GAIG;AACH,0CAJW,mBAAmB,WACnB,OAAO,GACL,MAAM,CAUlB;AAED;;;;GAIG;AACH,2CAJW,mBAAmB,WACnB,OAAO,GACL,MAAM,CAyBlB;AAED;;;GAGG;AACH,gCAHW,mBAAmB,GACjB,CAAC,MAAM,EAAE,MAAM,CAAC,CAI5B;yCAlbqG,aAAa;yCAAb,aAAa"}
+{"version":3,"file":"LoadedScriptsWriter.d.ts","sourceRoot":"","sources":["../../src/codegen/LoadedScriptsWriter.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;GAIG;AACH,0DAHW,OAAO,aAAa,EAAE,eAAe,GACnC,mBAAmB,CAI/B;AAsYD;;;;GAIG;AACH,0CAJW,mBAAmB,WACnB,OAAO,GACL,MAAM,CAUlB;AAED;;;;GAIG;AACH,2CAJW,mBAAmB,WACnB,OAAO,GACL,MAAM,CAyBlB;AAED;;;GAGG;AACH,gCAHW,mBAAmB,GACjB,CAAC,MAAM,EAAE,MAAM,CAAC,CAI5B;yCAncqG,aAAa;yCAAb,aAAa"}

package/types/context/ContractContextBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ContractContextBuilder.d.ts","sourceRoot":"","sources":["../../src/context/ContractContextBuilder.js"],"names":[],"mappings":"AAMA;;;GAGG;AAEH;;GAEG;AACH,8CAFa,uBAAuB,EAAE,EAAE,EAAE,CAAC,CAI1C;4CARqK,aAAa"}
+{"version":3,"file":"ContractContextBuilder.d.ts","sourceRoot":"","sources":["../../src/context/ContractContextBuilder.js"],"names":[],"mappings":"AAOA;;;GAGG;AAEH;;GAEG;AACH,8CAFa,uBAAuB,EAAE,EAAE,EAAE,CAAC,CAI1C;4CARqK,aAAa"}

package/types/context/debugger.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Bind credentials after cache lookup, keeping shared compilation caches credential-free.
+ * @param {import('./CacheEntry.js').CacheEntry} compiled
+ * @param {Record<string, import('../index.js').LoadedValidator>} validators
+ * @param {Record<string, import('../index.js').LoadedModule>} modules
+ * @returns {import('./CacheEntry.js').CacheEntry}
+ */
+export function bindDebuggerContexts(compiled: import("./CacheEntry.js").CacheEntry, validators: Record<string, import("../index.js").LoadedValidator>, modules: Record<string, import("../index.js").LoadedModule>): import("./CacheEntry.js").CacheEntry;
+//# sourceMappingURL=debugger.d.ts.map

package/types/context/debugger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debugger.d.ts","sourceRoot":"","sources":["../../src/context/debugger.js"],"names":[],"mappings":"AACA;;;;;;GAMG;AACH,+CALW,OAAO,iBAAiB,EAAE,UAAU,cACpC,MAAM,CAAC,MAAM,EAAE,OAAO,aAAa,EAAE,eAAe,CAAC,WACrD,MAAM,CAAC,MAAM,EAAE,OAAO,aAAa,EAAE,YAAY,CAAC,GAChD,OAAO,iBAAiB,EAAE,UAAU,CA4BhD"}

package/types/hl2ts.d.ts

@@ -1,8 +1,3 @@
 #!/usr/bin/env node
-export type SourceDetails = {
-    name: string;
-    purpose: string;
-    sourceCode: string;
-};
-export type FormatKind = "javascript" | "typescript";
+export {};
 //# sourceMappingURL=hl2ts.d.ts.map

package/types/hl2ts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hl2ts.d.ts","sourceRoot":"","sources":["../src/hl2ts.js"],"names":[],"mappings":";4BAgBa;IACR,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;CACnB;yBAIS,YAAY,GAAG,YAAY"}
+{"version":3,"file":"hl2ts.d.ts","sourceRoot":"","sources":["../src/hl2ts.js"],"names":[],"mappings":""}