detect-libc 2.1.2: method

# Notes: detect-libc method property deprecation and v2 API migration

## `search_known_solution` Result
`search_known_solution` returned NO_SAFE_MATCH for verifying `detect-libc.method` in `pkg:npm/detect-libc@2.1.2`.

## What a Naive Model Would Write
A naive model migrating from `detect-libc` v1 expects `detectLibc.method` to be a string identifying the detection strategy (e.g., `'filesystem'`, `'getconf'`), or attempts to call `detectLibc.method()` as a function to re-run detection.

## How the Wrong Version Fails
In `detect-libc` v2 (`2.1.2`), `method` has been completely removed from package exports and the module object (`detectLibc.method === undefined`). Code assuming `detectLibc.method` exists or calling `detectLibc.method()` throws `TypeError: detectLibc.method is not a function`. Robust callers must verify the absence of `method`, handle undefined safely, and migrate to direct inspection via `family()` / `familySync()`, `version()` / `versionSync()`, and `isNonGlibcLinux()` / `isNonGlibcLinuxSync()`.

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify detect-libc.method in pkg:npm/detect-libc@2.1.2
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/detect-libc@2.1.2
Demonstrate these symbols/APIs:
  - detect-libc.method

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:71f298e0fb86785e5e6ff755afefe8acde9a120b9cb542b08f75e9119d5be6f1","contract":["assert detect-libc.method is undefined in detect-libc@2.1.2 following removal of legacy v1 property","assert attempting to invoke detect-libc.method throws a TypeError","assert inspectLegacyMethod confirms method property does not exist on the export object","assert GLIBC ('glibc') and MUSL ('musl') string constants are exported","assert family, familySync, version, versionSync, isNonGlibcLinux, and isNonGlibcLinuxSync functions are exported","assert synchronous and asynchronous resolution yield identical libc results without relying on method"],"goal":"verify detect-libc.method in pkg:npm/detect-libc@2.1.2","kind":"HOW","packages":["pkg:npm/detect-libc@2.1.2"],"schemaVersion":1,"symbols":["detect-libc.method"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"cjs","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/detect-libc@2.1.2"],"schemaVersion":1,"subject":"pkg:npm/detect-libc@2.1.2","symbols":["detect-libc.method"],"verifierAdapter":"node-typescript@1"}

{
  "name": "detect-libc-method-verification",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "detect-libc-method-verification",
      "version": "1.0.0",
      "dependencies": {
        "detect-libc": "2.1.2"
      }
    },
    "node_modules/detect-libc": {
      "version": "2.1.2",
      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
      "license": "Apache-2.0",
      "engines": {
        "node": ">=8"
      }
    }
  }
}

{
  "name": "detect-libc-method-verification",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "dependencies": {
    "detect-libc": "2.1.2"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify detect-libc.method in pkg:npm/detect-libc@2.1.2",
  "kind": "HOW",
  "packages": [
    "pkg:npm/detect-libc@2.1.2"
  ],
  "symbols": [
    "detect-libc.method"
  ]
}

import detectLibc, {
  GLIBC,
  MUSL,
  family,
  familySync,
  isNonGlibcLinux,
  isNonGlibcLinuxSync,
  version,
  versionSync,
} from 'detect-libc';

/**
 * Inspects legacy method property vs modern detection functions.
 * In detect-libc v1, `method` was a string indicating the detection mechanism.
 * In detect-libc v2 (2.1.2), `method` is removed and undefined.
 *
 * @returns {{ hasLegacyMethod: boolean, methodValue: unknown }}
 */
export function inspectLegacyMethod() {
  return {
    hasLegacyMethod: 'method' in detectLibc && detectLibc.method !== undefined,
    methodValue: detectLibc.method,
  };
}

/**
 * Safely invokes or accesses method, demonstrating that calling method throws TypeError.
 *
 * @returns {{ threwTypeError: boolean, errorMessage: string | null }}
 */
export function safeInvokeMethod() {
  try {
    if (typeof detectLibc.method === 'function') {
      detectLibc.method();
      return { threwTypeError: false, errorMessage: null };
    }
    // Invoking undefined as function should throw TypeError
    const fn = detectLibc.method;
    fn();
    return { threwTypeError: false, errorMessage: null };
  } catch (err) {
    return {
      threwTypeError: err instanceof TypeError,
      errorMessage: err.message,
    };
  }
}

/**
 * Resolves libc information without relying on the removed `method` property.
 * Migrates callers from v1 method/property checks to v2 sync and async functions.
 *
 * @returns {Promise<{ family: string | null, version: string | null, isNonGlibc: boolean, method: undefined }>}
 */
export async function resolveLibcInfo() {
  const [fam, ver, nonGlibc] = await Promise.all([
    family(),
    version(),
    isNonGlibcLinux(),
  ]);

  return {
    family: fam,
    version: ver,
    isNonGlibc: nonGlibc,
    method: detectLibc.method,
  };
}

/**
 * Synchronous variant of resolveLibcInfo.
 *
 * @returns {{ family: string | null, version: string | null, isNonGlibc: boolean, method: undefined }}
 */
export function resolveLibcInfoSync() {
  return {
    family: familySync(),
    version: versionSync(),
    isNonGlibc: isNonGlibcLinuxSync(),
    method: detectLibc.method,
  };
}

import assert from 'node:assert/strict';
import detectLibc, {
  GLIBC,
  MUSL,
  family,
  familySync,
  isNonGlibcLinux,
  isNonGlibcLinuxSync,
  version,
  versionSync,
} from 'detect-libc';

import {
  inspectLegacyMethod,
  safeInvokeMethod,
  resolveLibcInfo,
  resolveLibcInfoSync,
} from '../src/detect-method.mjs';

// 1. Assert detect-libc.method is removed and undefined in detect-libc@2.1.2
assert.equal(detectLibc.method, undefined, 'detect-libc.method must be undefined in v2');
assert.equal('method' in detectLibc, false, "'method' property should not be an own or enumerable property");

// 2. Assert invoking detect-libc.method throws TypeError
const invokeResult = safeInvokeMethod();
assert.equal(invokeResult.threwTypeError, true, 'Calling detectLibc.method() must throw TypeError');

// 3. Assert inspectLegacyMethod reports absence of method
const legacyInspection = inspectLegacyMethod();
assert.equal(legacyInspection.hasLegacyMethod, false);
assert.equal(legacyInspection.methodValue, undefined);

// 4. Assert export constants and core detection functions exist
assert.equal(GLIBC, 'glibc');
assert.equal(MUSL, 'musl');
assert.equal(typeof family, 'function');
assert.equal(typeof familySync, 'function');
assert.equal(typeof isNonGlibcLinux, 'function');
assert.equal(typeof isNonGlibcLinuxSync, 'function');
assert.equal(typeof version, 'function');
assert.equal(typeof versionSync, 'function');

// 5. Assert synchronous libc resolution succeeds without method property
const syncInfo = resolveLibcInfoSync();
assert.equal(syncInfo.method, undefined);
if (process.platform === 'linux') {
  assert.ok(syncInfo.family === GLIBC || syncInfo.family === MUSL || syncInfo.family === null);
  if (syncInfo.family === GLIBC) {
    assert.equal(syncInfo.isNonGlibc, false);
  } else if (syncInfo.family === MUSL) {
    assert.equal(syncInfo.isNonGlibc, true);
  }
} else {
  assert.equal(syncInfo.family, null);
  assert.equal(syncInfo.version, null);
  assert.equal(syncInfo.isNonGlibc, false);
}

// 6. Assert asynchronous libc resolution matches synchronous resolution
const asyncInfo = await resolveLibcInfo();
assert.deepEqual(asyncInfo, syncInfo, 'Async and sync libc info must match');

console.log('Contract verified successfully!');