@gjsify/http2 0.1.0

package/README.md

@@ -0,0 +1,25 @@
+# @gjsify/http2
+
+GJS stub implementation of the Node.js `http2` module. Currently provides constants only.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/http2
+# or
+yarn add @gjsify/http2
+```
+
+## Usage
+
+```typescript
+import { constants } from '@gjsify/http2';
+
+console.log(constants.HTTP2_HEADER_STATUS);
+```
+
+## License
+
+MIT

package/lib/esm/index.js

@@ -0,0 +1,575 @@
+import { EventEmitter } from "node:events";
+const constants = {
+  // NGHTTP2 Error Codes (RFC 7540 §7)
+  NGHTTP2_NO_ERROR: 0,
+  NGHTTP2_PROTOCOL_ERROR: 1,
+  NGHTTP2_INTERNAL_ERROR: 2,
+  NGHTTP2_FLOW_CONTROL_ERROR: 3,
+  NGHTTP2_SETTINGS_TIMEOUT: 4,
+  NGHTTP2_STREAM_CLOSED: 5,
+  NGHTTP2_FRAME_SIZE_ERROR: 6,
+  NGHTTP2_REFUSED_STREAM: 7,
+  NGHTTP2_CANCEL: 8,
+  NGHTTP2_COMPRESSION_ERROR: 9,
+  NGHTTP2_CONNECT_ERROR: 10,
+  NGHTTP2_ENHANCE_YOUR_CALM: 11,
+  NGHTTP2_INADEQUATE_SECURITY: 12,
+  NGHTTP2_HTTP_1_1_REQUIRED: 13,
+  NGHTTP2_ERR_FRAME_SIZE_ERROR: -522,
+  NGHTTP2_ERR_DEFERRED: -508,
+  NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE: -509,
+  NGHTTP2_ERR_INVALID_ARGUMENT: -501,
+  NGHTTP2_ERR_STREAM_CLOSED: -510,
+  NGHTTP2_ERR_NOMEM: -901,
+  NGHTTP2_SESSION_SERVER: 0,
+  NGHTTP2_SESSION_CLIENT: 1,
+  NGHTTP2_STREAM_STATE_IDLE: 1,
+  NGHTTP2_STREAM_STATE_OPEN: 2,
+  NGHTTP2_STREAM_STATE_RESERVED_LOCAL: 3,
+  NGHTTP2_STREAM_STATE_RESERVED_REMOTE: 4,
+  NGHTTP2_STREAM_STATE_HALF_CLOSED_LOCAL: 5,
+  NGHTTP2_STREAM_STATE_HALF_CLOSED_REMOTE: 6,
+  NGHTTP2_STREAM_STATE_CLOSED: 7,
+  NGHTTP2_FLAG_NONE: 0,
+  NGHTTP2_FLAG_END_STREAM: 1,
+  NGHTTP2_FLAG_END_HEADERS: 4,
+  NGHTTP2_FLAG_ACK: 1,
+  NGHTTP2_FLAG_PADDED: 8,
+  NGHTTP2_FLAG_PRIORITY: 32,
+  NGHTTP2_HCAT_REQUEST: 0,
+  NGHTTP2_HCAT_RESPONSE: 1,
+  NGHTTP2_HCAT_PUSH_RESPONSE: 2,
+  NGHTTP2_HCAT_HEADERS: 3,
+  NGHTTP2_NV_FLAG_NONE: 0,
+  NGHTTP2_NV_FLAG_NO_INDEX: 1,
+  NGHTTP2_SETTINGS_HEADER_TABLE_SIZE: 1,
+  NGHTTP2_SETTINGS_ENABLE_PUSH: 2,
+  NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS: 3,
+  NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE: 4,
+  NGHTTP2_SETTINGS_MAX_FRAME_SIZE: 5,
+  NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE: 6,
+  NGHTTP2_SETTINGS_ENABLE_CONNECT_PROTOCOL: 8,
+  DEFAULT_SETTINGS_HEADER_TABLE_SIZE: 4096,
+  DEFAULT_SETTINGS_ENABLE_PUSH: 1,
+  DEFAULT_SETTINGS_MAX_CONCURRENT_STREAMS: 4294967295,
+  DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE: 65535,
+  DEFAULT_SETTINGS_MAX_FRAME_SIZE: 16384,
+  DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE: 65535,
+  DEFAULT_SETTINGS_ENABLE_CONNECT_PROTOCOL: 0,
+  MAX_MAX_FRAME_SIZE: 16777215,
+  MIN_MAX_FRAME_SIZE: 16384,
+  MAX_INITIAL_WINDOW_SIZE: 2147483647,
+  NGHTTP2_DEFAULT_WEIGHT: 16,
+  PADDING_STRATEGY_NONE: 0,
+  PADDING_STRATEGY_ALIGNED: 1,
+  PADDING_STRATEGY_MAX: 2,
+  PADDING_STRATEGY_CALLBACK: 1,
+  HTTP2_HEADER_STATUS: ":status",
+  HTTP2_HEADER_METHOD: ":method",
+  HTTP2_HEADER_AUTHORITY: ":authority",
+  HTTP2_HEADER_SCHEME: ":scheme",
+  HTTP2_HEADER_PATH: ":path",
+  HTTP2_HEADER_PROTOCOL: ":protocol",
+  HTTP2_HEADER_ACCEPT: "accept",
+  HTTP2_HEADER_ACCEPT_CHARSET: "accept-charset",
+  HTTP2_HEADER_ACCEPT_ENCODING: "accept-encoding",
+  HTTP2_HEADER_ACCEPT_LANGUAGE: "accept-language",
+  HTTP2_HEADER_ACCEPT_RANGES: "accept-ranges",
+  HTTP2_HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS: "access-control-allow-credentials",
+  HTTP2_HEADER_ACCESS_CONTROL_ALLOW_HEADERS: "access-control-allow-headers",
+  HTTP2_HEADER_ACCESS_CONTROL_ALLOW_METHODS: "access-control-allow-methods",
+  HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN: "access-control-allow-origin",
+  HTTP2_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS: "access-control-expose-headers",
+  HTTP2_HEADER_ACCESS_CONTROL_MAX_AGE: "access-control-max-age",
+  HTTP2_HEADER_ACCESS_CONTROL_REQUEST_HEADERS: "access-control-request-headers",
+  HTTP2_HEADER_ACCESS_CONTROL_REQUEST_METHOD: "access-control-request-method",
+  HTTP2_HEADER_AGE: "age",
+  HTTP2_HEADER_ALLOW: "allow",
+  HTTP2_HEADER_ALT_SVC: "alt-svc",
+  HTTP2_HEADER_AUTHORIZATION: "authorization",
+  HTTP2_HEADER_CACHE_CONTROL: "cache-control",
+  HTTP2_HEADER_CONNECTION: "connection",
+  HTTP2_HEADER_CONTENT_DISPOSITION: "content-disposition",
+  HTTP2_HEADER_CONTENT_ENCODING: "content-encoding",
+  HTTP2_HEADER_CONTENT_LANGUAGE: "content-language",
+  HTTP2_HEADER_CONTENT_LENGTH: "content-length",
+  HTTP2_HEADER_CONTENT_LOCATION: "content-location",
+  HTTP2_HEADER_CONTENT_MD5: "content-md5",
+  HTTP2_HEADER_CONTENT_RANGE: "content-range",
+  HTTP2_HEADER_CONTENT_SECURITY_POLICY: "content-security-policy",
+  HTTP2_HEADER_CONTENT_TYPE: "content-type",
+  HTTP2_HEADER_COOKIE: "cookie",
+  HTTP2_HEADER_DATE: "date",
+  HTTP2_HEADER_DNT: "dnt",
+  HTTP2_HEADER_EARLY_DATA: "early-data",
+  HTTP2_HEADER_ETAG: "etag",
+  HTTP2_HEADER_EXPECT: "expect",
+  HTTP2_HEADER_EXPECT_CT: "expect-ct",
+  HTTP2_HEADER_EXPIRES: "expires",
+  HTTP2_HEADER_FORWARDED: "forwarded",
+  HTTP2_HEADER_FROM: "from",
+  HTTP2_HEADER_HOST: "host",
+  HTTP2_HEADER_HTTP2_SETTINGS: "http2-settings",
+  HTTP2_HEADER_IF_MATCH: "if-match",
+  HTTP2_HEADER_IF_MODIFIED_SINCE: "if-modified-since",
+  HTTP2_HEADER_IF_NONE_MATCH: "if-none-match",
+  HTTP2_HEADER_IF_RANGE: "if-range",
+  HTTP2_HEADER_IF_UNMODIFIED_SINCE: "if-unmodified-since",
+  HTTP2_HEADER_KEEP_ALIVE: "keep-alive",
+  HTTP2_HEADER_LAST_MODIFIED: "last-modified",
+  HTTP2_HEADER_LINK: "link",
+  HTTP2_HEADER_LOCATION: "location",
+  HTTP2_HEADER_MAX_FORWARDS: "max-forwards",
+  HTTP2_HEADER_ORIGIN: "origin",
+  HTTP2_HEADER_PREFER: "prefer",
+  HTTP2_HEADER_PRIORITY: "priority",
+  HTTP2_HEADER_PROXY_AUTHENTICATE: "proxy-authenticate",
+  HTTP2_HEADER_PROXY_AUTHORIZATION: "proxy-authorization",
+  HTTP2_HEADER_PROXY_CONNECTION: "proxy-connection",
+  HTTP2_HEADER_RANGE: "range",
+  HTTP2_HEADER_REFERER: "referer",
+  HTTP2_HEADER_REFRESH: "refresh",
+  HTTP2_HEADER_RETRY_AFTER: "retry-after",
+  HTTP2_HEADER_SERVER: "server",
+  HTTP2_HEADER_SET_COOKIE: "set-cookie",
+  HTTP2_HEADER_STRICT_TRANSPORT_SECURITY: "strict-transport-security",
+  HTTP2_HEADER_TE: "te",
+  HTTP2_HEADER_TIMING_ALLOW_ORIGIN: "timing-allow-origin",
+  HTTP2_HEADER_TRAILER: "trailer",
+  HTTP2_HEADER_TRANSFER_ENCODING: "transfer-encoding",
+  HTTP2_HEADER_TK: "tk",
+  HTTP2_HEADER_UPGRADE: "upgrade",
+  HTTP2_HEADER_UPGRADE_INSECURE_REQUESTS: "upgrade-insecure-requests",
+  HTTP2_HEADER_USER_AGENT: "user-agent",
+  HTTP2_HEADER_VARY: "vary",
+  HTTP2_HEADER_VIA: "via",
+  HTTP2_HEADER_WARNING: "warning",
+  HTTP2_HEADER_WWW_AUTHENTICATE: "www-authenticate",
+  HTTP2_HEADER_X_CONTENT_TYPE_OPTIONS: "x-content-type-options",
+  HTTP2_HEADER_X_FORWARDED_FOR: "x-forwarded-for",
+  HTTP2_HEADER_X_FRAME_OPTIONS: "x-frame-options",
+  HTTP2_HEADER_X_XSS_PROTECTION: "x-xss-protection",
+  HTTP2_HEADER_PURPOSE: "purpose",
+  HTTP2_METHOD_ACL: "ACL",
+  HTTP2_METHOD_BASELINE_CONTROL: "BASELINE-CONTROL",
+  HTTP2_METHOD_BIND: "BIND",
+  HTTP2_METHOD_CHECKIN: "CHECKIN",
+  HTTP2_METHOD_CHECKOUT: "CHECKOUT",
+  HTTP2_METHOD_CONNECT: "CONNECT",
+  HTTP2_METHOD_COPY: "COPY",
+  HTTP2_METHOD_DELETE: "DELETE",
+  HTTP2_METHOD_GET: "GET",
+  HTTP2_METHOD_HEAD: "HEAD",
+  HTTP2_METHOD_LABEL: "LABEL",
+  HTTP2_METHOD_LINK: "LINK",
+  HTTP2_METHOD_LOCK: "LOCK",
+  HTTP2_METHOD_MERGE: "MERGE",
+  HTTP2_METHOD_MKACTIVITY: "MKACTIVITY",
+  HTTP2_METHOD_MKCALENDAR: "MKCALENDAR",
+  HTTP2_METHOD_MKCOL: "MKCOL",
+  HTTP2_METHOD_MKREDIRECTREF: "MKREDIRECTREF",
+  HTTP2_METHOD_MKWORKSPACE: "MKWORKSPACE",
+  HTTP2_METHOD_MOVE: "MOVE",
+  HTTP2_METHOD_OPTIONS: "OPTIONS",
+  HTTP2_METHOD_ORDERPATCH: "ORDERPATCH",
+  HTTP2_METHOD_PATCH: "PATCH",
+  HTTP2_METHOD_POST: "POST",
+  HTTP2_METHOD_PRI: "PRI",
+  HTTP2_METHOD_PROPFIND: "PROPFIND",
+  HTTP2_METHOD_PROPPATCH: "PROPPATCH",
+  HTTP2_METHOD_PUT: "PUT",
+  HTTP2_METHOD_REBIND: "REBIND",
+  HTTP2_METHOD_REPORT: "REPORT",
+  HTTP2_METHOD_SEARCH: "SEARCH",
+  HTTP2_METHOD_TRACE: "TRACE",
+  HTTP2_METHOD_UNBIND: "UNBIND",
+  HTTP2_METHOD_UNCHECKOUT: "UNCHECKOUT",
+  HTTP2_METHOD_UNLINK: "UNLINK",
+  HTTP2_METHOD_UNLOCK: "UNLOCK",
+  HTTP2_METHOD_UPDATE: "UPDATE",
+  HTTP2_METHOD_UPDATEREDIRECTREF: "UPDATEREDIRECTREF",
+  HTTP2_METHOD_VERSION_CONTROL: "VERSION-CONTROL",
+  HTTP_STATUS_CONTINUE: 100,
+  HTTP_STATUS_SWITCHING_PROTOCOLS: 101,
+  HTTP_STATUS_PROCESSING: 102,
+  HTTP_STATUS_EARLY_HINTS: 103,
+  HTTP_STATUS_OK: 200,
+  HTTP_STATUS_CREATED: 201,
+  HTTP_STATUS_ACCEPTED: 202,
+  HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION: 203,
+  HTTP_STATUS_NO_CONTENT: 204,
+  HTTP_STATUS_RESET_CONTENT: 205,
+  HTTP_STATUS_PARTIAL_CONTENT: 206,
+  HTTP_STATUS_MULTI_STATUS: 207,
+  HTTP_STATUS_ALREADY_REPORTED: 208,
+  HTTP_STATUS_IM_USED: 226,
+  HTTP_STATUS_MULTIPLE_CHOICES: 300,
+  HTTP_STATUS_MOVED_PERMANENTLY: 301,
+  HTTP_STATUS_FOUND: 302,
+  HTTP_STATUS_SEE_OTHER: 303,
+  HTTP_STATUS_NOT_MODIFIED: 304,
+  HTTP_STATUS_USE_PROXY: 305,
+  HTTP_STATUS_TEMPORARY_REDIRECT: 307,
+  HTTP_STATUS_PERMANENT_REDIRECT: 308,
+  HTTP_STATUS_BAD_REQUEST: 400,
+  HTTP_STATUS_UNAUTHORIZED: 401,
+  HTTP_STATUS_PAYMENT_REQUIRED: 402,
+  HTTP_STATUS_FORBIDDEN: 403,
+  HTTP_STATUS_NOT_FOUND: 404,
+  HTTP_STATUS_METHOD_NOT_ALLOWED: 405,
+  HTTP_STATUS_NOT_ACCEPTABLE: 406,
+  HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED: 407,
+  HTTP_STATUS_REQUEST_TIMEOUT: 408,
+  HTTP_STATUS_CONFLICT: 409,
+  HTTP_STATUS_GONE: 410,
+  HTTP_STATUS_LENGTH_REQUIRED: 411,
+  HTTP_STATUS_PRECONDITION_FAILED: 412,
+  HTTP_STATUS_PAYLOAD_TOO_LARGE: 413,
+  HTTP_STATUS_URI_TOO_LONG: 414,
+  HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE: 415,
+  HTTP_STATUS_RANGE_NOT_SATISFIABLE: 416,
+  HTTP_STATUS_EXPECTATION_FAILED: 417,
+  HTTP_STATUS_TEAPOT: 418,
+  HTTP_STATUS_MISDIRECTED_REQUEST: 421,
+  HTTP_STATUS_UNPROCESSABLE_ENTITY: 422,
+  HTTP_STATUS_LOCKED: 423,
+  HTTP_STATUS_FAILED_DEPENDENCY: 424,
+  HTTP_STATUS_TOO_EARLY: 425,
+  HTTP_STATUS_UPGRADE_REQUIRED: 426,
+  HTTP_STATUS_PRECONDITION_REQUIRED: 428,
+  HTTP_STATUS_TOO_MANY_REQUESTS: 429,
+  HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+  HTTP_STATUS_UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+  HTTP_STATUS_INTERNAL_SERVER_ERROR: 500,
+  HTTP_STATUS_NOT_IMPLEMENTED: 501,
+  HTTP_STATUS_BAD_GATEWAY: 502,
+  HTTP_STATUS_SERVICE_UNAVAILABLE: 503,
+  HTTP_STATUS_GATEWAY_TIMEOUT: 504,
+  HTTP_STATUS_HTTP_VERSION_NOT_SUPPORTED: 505,
+  HTTP_STATUS_VARIANT_ALSO_NEGOTIATES: 506,
+  HTTP_STATUS_INSUFFICIENT_STORAGE: 507,
+  HTTP_STATUS_LOOP_DETECTED: 508,
+  HTTP_STATUS_BANDWIDTH_LIMIT_EXCEEDED: 509,
+  HTTP_STATUS_NOT_EXTENDED: 510,
+  HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED: 511
+};
+const SETTINGS_MAP = [
+  [1, "headerTableSize", false],
+  [2, "enablePush", true],
+  [3, "maxConcurrentStreams", false],
+  [4, "initialWindowSize", false],
+  [5, "maxFrameSize", false],
+  [6, "maxHeaderListSize", false],
+  [8, "enableConnectProtocol", true]
+];
+function getDefaultSettings() {
+  return {
+    headerTableSize: 4096,
+    enablePush: true,
+    maxConcurrentStreams: 4294967295,
+    initialWindowSize: 65535,
+    maxFrameSize: 16384,
+    maxHeaderListSize: 65535,
+    enableConnectProtocol: false
+  };
+}
+function getPackedSettings(settings) {
+  if (!settings) return new Uint8Array(0);
+  const pairs = [];
+  for (const [id, key, isBool] of SETTINGS_MAP) {
+    const val = settings[key];
+    if (val !== void 0) {
+      pairs.push([id, isBool ? val ? 1 : 0 : val]);
+    }
+  }
+  const buf = new Uint8Array(pairs.length * 6);
+  const view = new DataView(buf.buffer);
+  for (let i = 0; i < pairs.length; i++) {
+    const offset = i * 6;
+    view.setUint16(offset, pairs[i][0], false);
+    view.setUint32(offset + 2, pairs[i][1], false);
+  }
+  return buf;
+}
+function getUnpackedSettings(buf) {
+  const data = buf instanceof ArrayBuffer ? new Uint8Array(buf) : buf;
+  if (data.byteLength % 6 !== 0) {
+    throw new RangeError("Invalid packed settings length");
+  }
+  const result = {};
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  for (let i = 0; i < data.byteLength; i += 6) {
+    const id = view.getUint16(i, false);
+    const value = view.getUint32(i + 2, false);
+    for (const [settingId, key, isBool] of SETTINGS_MAP) {
+      if (id === settingId) {
+        result[key] = isBool ? value !== 0 : value;
+        break;
+      }
+    }
+  }
+  return result;
+}
+class Http2Session extends EventEmitter {
+  alpnProtocol = void 0;
+  encrypted = false;
+  type = constants.NGHTTP2_SESSION_CLIENT;
+  _closed = false;
+  _destroyed = false;
+  _settings;
+  constructor() {
+    super();
+    this._settings = getDefaultSettings();
+  }
+  get closed() {
+    return this._closed;
+  }
+  get destroyed() {
+    return this._destroyed;
+  }
+  get connecting() {
+    return false;
+  }
+  get pendingSettingsAck() {
+    return false;
+  }
+  get localSettings() {
+    return { ...this._settings };
+  }
+  get remoteSettings() {
+    return getDefaultSettings();
+  }
+  settings(settings, callback) {
+    Object.assign(this._settings, settings);
+    if (callback) Promise.resolve().then(callback);
+  }
+  goaway(code, _lastStreamId, _data) {
+    this.emit("goaway", code ?? constants.NGHTTP2_NO_ERROR);
+  }
+  ping(payload, callback) {
+    const buf = payload || new Uint8Array(8);
+    if (callback) Promise.resolve().then(() => callback(null, 0, buf));
+    return true;
+  }
+  close(callback) {
+    if (this._closed) return;
+    this._closed = true;
+    this.emit("close");
+    if (callback) callback();
+  }
+  destroy(error, code) {
+    if (this._destroyed) return;
+    this._destroyed = true;
+    this._closed = true;
+    if (error) this.emit("error", error);
+    this.emit("close");
+    if (code !== void 0) {
+      this.goaway(code);
+    }
+  }
+  ref() {
+  }
+  unref() {
+  }
+}
+class ServerHttp2Session extends Http2Session {
+  type = constants.NGHTTP2_SESSION_SERVER;
+  altsvc(_alt, _originOrStream) {
+  }
+  origin(..._origins) {
+  }
+}
+class ClientHttp2Session extends Http2Session {
+  request(_headers, _options) {
+    throw new Error("http2 client requests are not yet implemented in GJS");
+  }
+}
+class Http2Stream extends EventEmitter {
+  id = 0;
+  session = null;
+  sentHeaders = {};
+  sentInfoHeaders = [];
+  _closed = false;
+  _destroyed = false;
+  _state = constants.NGHTTP2_STREAM_STATE_IDLE;
+  get closed() {
+    return this._closed;
+  }
+  get destroyed() {
+    return this._destroyed;
+  }
+  get pending() {
+    return this.id === 0;
+  }
+  get state() {
+    return this._state;
+  }
+  get endAfterHeaders() {
+    return false;
+  }
+  get bufferSize() {
+    return 0;
+  }
+  get rstCode() {
+    return constants.NGHTTP2_NO_ERROR;
+  }
+  close(code, callback) {
+    if (this._closed) return;
+    this._closed = true;
+    this._state = constants.NGHTTP2_STREAM_STATE_CLOSED;
+    this.emit("close", code ?? constants.NGHTTP2_NO_ERROR);
+    if (callback) callback();
+  }
+  destroy(error) {
+    if (this._destroyed) return;
+    this._destroyed = true;
+    this._closed = true;
+    this._state = constants.NGHTTP2_STREAM_STATE_CLOSED;
+    if (error) this.emit("error", error);
+    this.emit("close");
+  }
+  priority(_options) {
+  }
+  setTimeout(msecs, callback) {
+    if (callback) setTimeout(callback, msecs);
+  }
+}
+class ServerHttp2Stream extends Http2Stream {
+  headersSent = false;
+  pushAllowed = false;
+  respond(_headers, _options) {
+    throw new Error("http2 server respond is not yet implemented in GJS");
+  }
+  respondWithFD(_fd, _headers, _options) {
+    throw new Error("http2 respondWithFD is not yet implemented in GJS");
+  }
+  respondWithFile(_path, _headers, _options) {
+    throw new Error("http2 respondWithFile is not yet implemented in GJS");
+  }
+  pushStream(_headers, _options, _callback) {
+    throw new Error("http2 server push is not yet implemented in GJS");
+  }
+  additionalHeaders(_headers) {
+  }
+}
+class ClientHttp2Stream extends Http2Stream {
+}
+class Http2ServerRequest extends EventEmitter {
+  headers = {};
+  httpVersion = "2.0";
+  method = "GET";
+  url = "/";
+  stream = null;
+  authority = "";
+  scheme = "https";
+  get complete() {
+    return true;
+  }
+  setTimeout(msecs, callback) {
+    if (callback) setTimeout(callback, msecs);
+    return this;
+  }
+}
+class Http2ServerResponse extends EventEmitter {
+  statusCode = 200;
+  stream = null;
+  headersSent = false;
+  _headers = {};
+  setHeader(name, value) {
+    this._headers[name.toLowerCase()] = value;
+    return this;
+  }
+  getHeader(name) {
+    return this._headers[name.toLowerCase()];
+  }
+  getHeaders() {
+    return { ...this._headers };
+  }
+  removeHeader(name) {
+    delete this._headers[name.toLowerCase()];
+  }
+  hasHeader(name) {
+    return name.toLowerCase() in this._headers;
+  }
+  writeHead(statusCode, headers) {
+    this.statusCode = statusCode;
+    if (headers) {
+      for (const [name, value] of Object.entries(headers)) {
+        this._headers[name.toLowerCase()] = value;
+      }
+    }
+    return this;
+  }
+  end(_data, _encoding, _callback) {
+    this.emit("finish");
+    return this;
+  }
+  write(_chunk, _encoding, _callback) {
+    return true;
+  }
+  createPushResponse(_headers, _callback) {
+    throw new Error("http2 server push is not yet implemented in GJS");
+  }
+  setTimeout(msecs, callback) {
+    if (callback) setTimeout(callback, msecs);
+    return this;
+  }
+}
+function createServer(_options, _onRequestHandler) {
+  throw new Error(
+    "http2.createServer() is not yet implemented in GJS. Soup 3.0 handles HTTP/2 transparently but does not expose multiplexed streams. Use http.createServer() for HTTP/1.1 or consider a future nghttp2-based implementation."
+  );
+}
+function createSecureServer(_options, _onRequestHandler) {
+  throw new Error(
+    "http2.createSecureServer() is not yet implemented in GJS. Requires TLS server support combined with HTTP/2 multiplexing."
+  );
+}
+function connect(_authority, _options, _listener) {
+  throw new Error(
+    "http2.connect() is not yet implemented in GJS. Soup 3.0 can negotiate HTTP/2 transparently via Soup.Session, but does not expose the session/stream API needed for http2.connect()."
+  );
+}
+const sensitiveHeaders = /* @__PURE__ */ Symbol("http2.sensitiveHeaders");
+function performServerHandshake(_socket) {
+  throw new Error("http2.performServerHandshake() is not yet implemented in GJS");
+}
+var index_default = {
+  constants,
+  createServer,
+  createSecureServer,
+  connect,
+  getDefaultSettings,
+  getPackedSettings,
+  getUnpackedSettings,
+  sensitiveHeaders,
+  performServerHandshake,
+  Http2Session,
+  Http2Stream,
+  ServerHttp2Session,
+  ClientHttp2Session,
+  ServerHttp2Stream,
+  ClientHttp2Stream,
+  Http2ServerRequest,
+  Http2ServerResponse
+};
+export {
+  ClientHttp2Session,
+  ClientHttp2Stream,
+  Http2ServerRequest,
+  Http2ServerResponse,
+  Http2Session,
+  Http2Stream,
+  ServerHttp2Session,
+  ServerHttp2Stream,
+  connect,
+  constants,
+  createSecureServer,
+  createServer,
+  index_default as default,
+  getDefaultSettings,
+  getPackedSettings,
+  getUnpackedSettings,
+  performServerHandshake,
+  sensitiveHeaders
+};