burnless 0.1.0

package/dist/index.thin.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __pathDirname } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import {
+  LOCAL_VERBS,
+  buildRemoteProgram,
+  delegateToArtifact,
+  topVerb
+} from "./chunk-L24B5MJD.js";
+import "./chunk-BN3QFA6Z.js";
+import "./chunk-VKDF3OUE.js";
+import "./chunk-BMDIVUSL.js";
+
+// src/index.thin.ts
+async function main() {
+  const verb = topVerb(process.argv);
+  if (verb !== void 0 && LOCAL_VERBS.has(verb)) {
+    const code = await delegateToArtifact(process.argv);
+    process.exit(code);
+  }
+  const program = buildRemoteProgram();
+  program.exitOverride((err) => process.exit(err.exitCode === 0 ? 0 : 2));
+  program.addHelpText(
+    "after",
+    `
+Local-instance commands (download the app on first use): ${[...LOCAL_VERBS].sort().join(", ")}`
+  );
+  if (verb === void 0 && !process.argv.includes("-V") && !process.argv.includes("--version")) {
+    program.outputHelp();
+    process.exit(0);
+  }
+  await program.parseAsync(process.argv);
+}
+main().catch((err) => {
+  process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(2);
+});

package/dist/pglite-KKF2QVEJ.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __pathDirname } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import {
+  DefaultLogger,
+  NoopLogger,
+  PgDatabase,
+  PgDialect,
+  PgPreparedQuery,
+  PgSession,
+  PgTransaction,
+  createTableRelationsHelpers,
+  entityKind,
+  extractTablesRelationalConfig,
+  fillPlaceholders,
+  isConfig,
+  mapResultRow,
+  sql
+} from "./chunk-RDP4RLLI.js";
+import "./chunk-BMDIVUSL.js";
+
+// ../../node_modules/.pnpm/drizzle-orm@0.38.4_@electric-sql+pglite@0.5.2_@opentelemetry+api@1.9.0_@types+pg@8.15.6_75139cca41f10c6d94ac9ad65d4511ab/node_modules/drizzle-orm/pglite/driver.js
+import { PGlite } from "@electric-sql/pglite";
+
+// ../../node_modules/.pnpm/drizzle-orm@0.38.4_@electric-sql+pglite@0.5.2_@opentelemetry+api@1.9.0_@types+pg@8.15.6_75139cca41f10c6d94ac9ad65d4511ab/node_modules/drizzle-orm/pglite/session.js
+import { types } from "@electric-sql/pglite";
+var PglitePreparedQuery = class extends PgPreparedQuery {
+  constructor(client, queryString, params, logger, fields, name, _isResponseInArrayMode, customResultMapper) {
+    super({ sql: queryString, params });
+    this.client = client;
+    this.queryString = queryString;
+    this.params = params;
+    this.logger = logger;
+    this.fields = fields;
+    this._isResponseInArrayMode = _isResponseInArrayMode;
+    this.customResultMapper = customResultMapper;
+    this.rawQueryConfig = {
+      rowMode: "object",
+      parsers: {
+        [types.TIMESTAMP]: (value) => value,
+        [types.TIMESTAMPTZ]: (value) => value,
+        [types.INTERVAL]: (value) => value,
+        [types.DATE]: (value) => value
+      }
+    };
+    this.queryConfig = {
+      rowMode: "array",
+      parsers: {
+        [types.TIMESTAMP]: (value) => value,
+        [types.TIMESTAMPTZ]: (value) => value,
+        [types.INTERVAL]: (value) => value,
+        [types.DATE]: (value) => value
+      }
+    };
+  }
+  static [entityKind] = "PglitePreparedQuery";
+  rawQueryConfig;
+  queryConfig;
+  async execute(placeholderValues = {}) {
+    const params = fillPlaceholders(this.params, placeholderValues);
+    this.logger.logQuery(this.queryString, params);
+    const { fields, rawQueryConfig, client, queryConfig, joinsNotNullableMap, customResultMapper, queryString } = this;
+    if (!fields && !customResultMapper) {
+      return client.query(queryString, params, rawQueryConfig);
+    }
+    const result = await client.query(queryString, params, queryConfig);
+    return customResultMapper ? customResultMapper(result.rows) : result.rows.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
+  }
+  all(placeholderValues = {}) {
+    const params = fillPlaceholders(this.params, placeholderValues);
+    this.logger.logQuery(this.queryString, params);
+    return this.client.query(this.queryString, params, this.rawQueryConfig).then((result) => result.rows);
+  }
+  /** @internal */
+  isResponseInArrayMode() {
+    return this._isResponseInArrayMode;
+  }
+};
+var PgliteSession = class _PgliteSession extends PgSession {
+  constructor(client, dialect, schema, options = {}) {
+    super(dialect);
+    this.client = client;
+    this.schema = schema;
+    this.options = options;
+    this.logger = options.logger ?? new NoopLogger();
+  }
+  static [entityKind] = "PgliteSession";
+  logger;
+  prepareQuery(query, fields, name, isResponseInArrayMode, customResultMapper) {
+    return new PglitePreparedQuery(
+      this.client,
+      query.sql,
+      query.params,
+      this.logger,
+      fields,
+      name,
+      isResponseInArrayMode,
+      customResultMapper
+    );
+  }
+  async transaction(transaction, config) {
+    return this.client.transaction(async (client) => {
+      const session = new _PgliteSession(
+        client,
+        this.dialect,
+        this.schema,
+        this.options
+      );
+      const tx = new PgliteTransaction(this.dialect, session, this.schema);
+      if (config) {
+        await tx.setTransaction(config);
+      }
+      return transaction(tx);
+    });
+  }
+  async count(sql2) {
+    const res = await this.execute(sql2);
+    return Number(
+      res["rows"][0]["count"]
+    );
+  }
+};
+var PgliteTransaction = class _PgliteTransaction extends PgTransaction {
+  static [entityKind] = "PgliteTransaction";
+  async transaction(transaction) {
+    const savepointName = `sp${this.nestedIndex + 1}`;
+    const tx = new _PgliteTransaction(
+      this.dialect,
+      this.session,
+      this.schema,
+      this.nestedIndex + 1
+    );
+    await tx.execute(sql.raw(`savepoint ${savepointName}`));
+    try {
+      const result = await transaction(tx);
+      await tx.execute(sql.raw(`release savepoint ${savepointName}`));
+      return result;
+    } catch (err) {
+      await tx.execute(sql.raw(`rollback to savepoint ${savepointName}`));
+      throw err;
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.38.4_@electric-sql+pglite@0.5.2_@opentelemetry+api@1.9.0_@types+pg@8.15.6_75139cca41f10c6d94ac9ad65d4511ab/node_modules/drizzle-orm/pglite/driver.js
+var PgliteDriver = class {
+  constructor(client, dialect, options = {}) {
+    this.client = client;
+    this.dialect = dialect;
+    this.options = options;
+  }
+  static [entityKind] = "PgliteDriver";
+  createSession(schema) {
+    return new PgliteSession(this.client, this.dialect, schema, { logger: this.options.logger });
+  }
+};
+var PgliteDatabase = class extends PgDatabase {
+  static [entityKind] = "PgliteDatabase";
+};
+function construct(client, config = {}) {
+  const dialect = new PgDialect({ casing: config.casing });
+  let logger;
+  if (config.logger === true) {
+    logger = new DefaultLogger();
+  } else if (config.logger !== false) {
+    logger = config.logger;
+  }
+  let schema;
+  if (config.schema) {
+    const tablesConfig = extractTablesRelationalConfig(
+      config.schema,
+      createTableRelationsHelpers
+    );
+    schema = {
+      fullSchema: config.schema,
+      schema: tablesConfig.tables,
+      tableNamesMap: tablesConfig.tableNamesMap
+    };
+  }
+  const driver = new PgliteDriver(client, dialect, { logger });
+  const session = driver.createSession(schema);
+  const db = new PgliteDatabase(dialect, session, schema);
+  db.$client = client;
+  return db;
+}
+function drizzle(...params) {
+  if (params[0] === void 0 || typeof params[0] === "string") {
+    const instance = new PGlite(params[0]);
+    return construct(instance, params[1]);
+  }
+  if (isConfig(params[0])) {
+    const { connection, client, ...drizzleConfig } = params[0];
+    if (client)
+      return construct(client, drizzleConfig);
+    if (typeof connection === "object") {
+      const { dataDir, ...options } = connection;
+      const instance2 = new PGlite(dataDir, options);
+      return construct(instance2, drizzleConfig);
+    }
+    const instance = new PGlite(connection);
+    return construct(instance, drizzleConfig);
+  }
+  return construct(params[0], params[1]);
+}
+((drizzle2) => {
+  function mock(config) {
+    return construct({}, config);
+  }
+  drizzle2.mock = mock;
+})(drizzle || (drizzle = {}));
+export {
+  PgliteDatabase,
+  PgliteDriver,
+  PglitePreparedQuery,
+  PgliteSession,
+  PgliteTransaction,
+  drizzle
+};

package/dist/postgres-js-SQJTBL3M.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __pathDirname } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import {
+  PostgresJsDatabase,
+  PostgresJsPreparedQuery,
+  PostgresJsSession,
+  PostgresJsTransaction,
+  drizzle
+} from "./chunk-IBT7EFKB.js";
+import "./chunk-MHVBJUPX.js";
+import "./chunk-RDP4RLLI.js";
+import "./chunk-BMDIVUSL.js";
+export {
+  PostgresJsDatabase,
+  PostgresJsPreparedQuery,
+  PostgresJsSession,
+  PostgresJsTransaction,
+  drizzle
+};

package/dist/prompt-QYBNOJ26.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __pathDirname } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import {
+  readSecret
+} from "./chunk-M7YWG4WP.js";
+import "./chunk-BMDIVUSL.js";
+export {
+  readSecret
+};

package/dist/release-4OJIQHQH.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __pathDirname } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import {
+  PUBLIC_RELEASE_REPO,
+  downloadAndVerify,
+  ensureArtifact,
+  extractArtifact,
+  flipCurrent,
+  installedVersions,
+  publicReleaseBaseFor,
+  resolveReleaseSource,
+  versionsDir
+} from "./chunk-N7IP6VPJ.js";
+import "./chunk-BN3QFA6Z.js";
+import "./chunk-VKDF3OUE.js";
+import "./chunk-BMDIVUSL.js";
+export {
+  PUBLIC_RELEASE_REPO,
+  downloadAndVerify,
+  ensureArtifact,
+  extractArtifact,
+  flipCurrent,
+  installedVersions,
+  publicReleaseBaseFor,
+  resolveReleaseSource,
+  versionsDir
+};