@10p.io/webtransport-quiche 0.0.0-stage → 20.73.0

package/LICENSE

@@ -0,0 +1,39 @@
+This packages uses the libraries abseil, boringssl, quiche and zlib,
+these fall under their respective license.
+
+Portions of the code of this package, e.g. the platform implementation for libquiche,
+are taken from the Chromium project and libquiche and envoy project. 
+Basically for files taken from the Chromium project and libquiche the modfied BSD 3-Clause (see LICENSE.chromium) applies, where for the files taken from the envoy a Apache 2.0 (LICENSE.envoy) applies.
+
+For all new files (except FAILS logo) and modifications of the original files the following
+BSD 3-Clause license applies:
+
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    (1) Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer. 
+
+    (2) Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution.  
+    
+    (3)The name of the authors, FAILS or contributing organizations 
+    (company, organsations etc.)  may not be used to
+    endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE. 

package/LICENSE.chromium

@@ -0,0 +1,27 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/LICENSE.envoy

@@ -0,0 +1,207 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner].
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+© 2022 GitHub, Inc.
+Terms
+Privacy
+Security
+Status

package/README.md

@@ -1,3 +1,22 @@
-# Temporary Holding Version
+# @10p.io/webtransport-quiche
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[`@fails-components/webtransport-transport-http3-quiche`](https://github.com/fails-components/webtransport) 1.6.3 の JS をそのまま持ち、
+`lib/index.js` だけを差し替えて `webtransport.node` を platform 別 package (`@10p.io/webtransport-quiche-<platform>-<arch>`) から読む。
+
+upstream は install script (`prebuild-install`) で GitHub Release から binary を取るため、依存の install script を走らせない
+bun / pnpm では binary が入らない。この package は install script を持たず、binary は `optionalDependencies` で届く。
+
+planx (cli) は npm alias で upstream の名前に差し込む:
+
+```json
+"@fails-components/webtransport-transport-http3-quiche": "npm:@10p.io/webtransport-quiche@0.0.0-PLACEHOLDER"
+```
+
+## 版を上げる
+
+1. root `package.json` の upstream (`@fails-components/webtransport*`) を上げる
+2. `scripts/webtransport-quiche/checksums.json` を新しい Release の tarball の sha256 に置き換える
+3. 本 package と 5 つの platform package の `version` / `optionalDependencies`、cli の alias を同じ版にする
+4. platform package 5 つ → 本 package の順に `nx run <project>:deploy`
+
+設計: `projects/docs/design/feat/20261023_webtransport-quiche-platform-packages.md`

package/lib/clientsocket.js

@@ -0,0 +1,80 @@
+import { createSocket } from 'node:dgram'
+import { lookup } from 'node:dns/promises'
+
+import { logger } from './utils.js'
+import { Http3WebTransportSocket } from './socket.js'
+
+const log = logger(`webtransport:Http3WebTransportClientSocket(${process.pid})`)
+
+export class Http3WebTransportClientSocket extends Http3WebTransportSocket {
+  /**
+   * @param {import('../../../main/lib/types.js').HttpWebTransportInit} args
+   */
+  constructor(args) {
+    super(args)
+    let port = args?.port
+    if (typeof port === 'undefined') port = 443
+    this.port = Number(port)
+    this.host = args?.host || 'localhost'
+    this.localPort = args?.localPort
+    this.forceIpv6 = args?.forceIpv6 || false
+    /** @type {import('../../../main/lib/session.js').HttpClient} */
+    // @ts-ignore
+    this.jsobj = undefined // the transport will set this
+
+    this.args = args
+  }
+
+  init() {
+    lookup(this.host)
+      .then((result) => {
+        this.address = result
+        this.cobj.setHostname({
+          ...this.args,
+          serveraddress: result.address,
+          port: Number(this.args.port)
+        })
+        // @ts-ignore
+        delete this.args
+        this.socketInt = createSocket({
+          type: result.family === 4 ? 'udp4' : 'udp6',
+          ipv6Only: this.forceIpv6
+        })
+
+        this.socketInt.on('error', (evt) => {
+          this.jsobj.onClientError({ errorcode: 100, error: evt.toString() })
+        })
+
+        this.socketInt.on('close', () => {
+          //
+        })
+        this.socketInt.on('message', (msg, rinfo) => {
+          this.cobj.recvPaket({
+            msg,
+            rinfo,
+            selfaddress: this.socketInt.address()
+          })
+        })
+        this.socketInt.bind(this.localPort)
+        setImmediate(() => this.cobj.onCanWrite())
+      })
+      .catch((error) => {
+        log('Problem client:', error)
+        // hostname not known
+        this.jsobj.onClientError({
+          errorcode: 100,
+          error: 'Problem resolving hostname'
+        })
+      })
+  }
+
+  closeClient() {
+    process.nextTick(() => {
+      // TODO call close on all sessions
+      this.cobj.closeClientInt()
+      // close socket after sending close frames
+      this.socketInt.close()
+      this.closed = true
+    })
+  }
+}

package/lib/index.js

@@ -0,0 +1,37 @@
+import { existsSync } from 'fs'
+import { createRequire } from 'module'
+import * as url from 'url'
+import { arch, platform } from 'node:process'
+import { logger } from './utils.js'
+import { resolveBinary } from './resolve-binary.js'
+
+const log = logger(`webtransport:native(${process?.pid})`)
+const require = createRequire(import.meta.url)
+
+export const binaryPath = resolveBinary({
+  platform,
+  arch,
+  dirname: url.fileURLToPath(new URL('.', import.meta.url)),
+  exists: existsSync,
+  resolve: (id) => require.resolve(id)
+})
+log('load webtransport binary:', binaryPath)
+
+export const wtrouter = require(binaryPath)
+export const quicheInit = wtrouter.quicheInit
+
+let quicheInited = false
+
+export const checkQuicheInit = function (args) {
+  if (!quicheInited) {
+    quicheInit({
+      quicheLogVerbose: args?.quicheLogVerbose ? args.quicheLogVerbose : -1
+    })
+    quicheInited = true
+  }
+}
+
+export const Http3WebTransportClient = wtrouter.Http3WebTransportClient
+export const Http3WebTransportServer = wtrouter.Http3WebTransportServer
+export { Http3WebTransportClientSocket } from './clientsocket.js'
+export { Http3WebTransportServerSocket } from './serversocket.js'

package/lib/resolve-binary.js

@@ -0,0 +1,20 @@
+import * as path from 'path'
+
+export function resolveBinary({ platform, arch, dirname, exists, resolve }) {
+  const pkg = `@10p.io/webtransport-quiche-${platform}-${arch}/webtransport.node`
+  try {
+    return resolve(pkg)
+  } catch (error) {
+    if (error?.code !== 'MODULE_NOT_FOUND') throw error
+  }
+  const local = [
+    path.join(dirname, `../build_${platform}_${arch}/Release/webtransport.node`),
+    path.join(dirname, '../build/Release/webtransport.node')
+  ]
+  const found = local.find((p) => exists(p))
+  if (found) return found
+  throw new Error(
+    `webtransport.node が見つからない (${platform}-${arch}): ${[pkg, ...local].join(', ')}。` +
+      `optionalDependencies の ${pkg.split('/webtransport.node')[0]} が入っているか確認する`
+  )
+}

package/lib/serversocket.js

@@ -0,0 +1,86 @@
+import { createSocket } from 'node:dgram'
+import { lookup } from 'node:dns/promises'
+
+import { logger } from './utils.js'
+import { Http3WebTransportSocket } from './socket.js'
+
+const log = logger(`webtransport:Http3WebTransportServerSocket(${process.pid})`)
+
+export class Http3WebTransportServerSocket extends Http3WebTransportSocket {
+  /**
+   * @param {import('../../../main/lib/types.js').Http3QuicheServerWebTransportInit|undefined} args
+   */
+  constructor(args) {
+    super(args)
+    let port = args?.port
+    if (typeof port === 'undefined') port = 443
+    this.port = Number(port)
+    this.host = args?.host || 'localhost'
+    /** @type {import('../../../main/lib/session.js').HttpServer} */
+    // @ts-ignore
+    this.jsobj = undefined // the transport will set this
+
+    /** @type {import('node:dns').LookupAddress|undefined} */
+    this.address = undefined
+
+    this.socketOptions = args?.quicheNodeSocketOptions ?? {}
+  }
+
+  init() {
+    lookup(this.host)
+      .then((result) => {
+        this.address = result
+        this.socketInt = createSocket({
+          ...{
+            type: result.family === 4 ? 'udp4' : 'udp6',
+            reuseAddr: true
+          },
+          ...this.socketOptions
+        })
+
+        this.socketInt.on('listening', () => {
+          const addr = this.socketInt.address()
+          const retObj = {
+            port: addr?.port,
+            host: addr?.address
+          }
+          this.jsobj.onServerListening(retObj)
+        })
+
+        this.socketInt.on('error', (error) => {
+          this.jsobj.onServerError(error)
+        })
+
+        this.socketInt.on('close', () => {
+          this.jsobj.onServerClose()
+        })
+
+        this.socketInt.on('message', (msg, rinfo) => {
+          // console.log('srv msg', msg, rinfo)
+          const haschlos = this.cobj.recvPaket({
+            msg,
+            rinfo,
+            selfaddress: this.socketInt.address()
+          })
+          if (!this.chlosSched && haschlos) {
+            setImmediate(this.doProcessBufferedChlos)
+            this.chlosSched = true
+          }
+        })
+        this.socketInt.bind(this.port, this.address?.address)
+        this.cobj.onCanWrite()
+      })
+      .catch((error) => {
+        log('Problem server:', error)
+        // hostname not known
+        this.jsobj.onServerError(error)
+      })
+  }
+
+  stopServer() {
+    this.cobj.destroy()
+    this.socketInt.close()
+    this.closed = true
+    // TODO call close on all sessions
+  }
+}

package/lib/socket.js

@@ -0,0 +1,144 @@
+import { X509Certificate, createVerify } from 'node:crypto'
+import { logger } from './utils.js'
+import { rootCertificates } from 'node:tls'
+const log = logger(`webtransport:Http3WebTransportSocket(${process.pid})`)
+
+globalThis.FAILSsetTimeoutAlarm = (
+  /** @type {{ fireJS: () => void; }} */ alarm,
+  /** @type {number} */ delay
+) => {
+  if (delay < 1) {
+    return { immediate: setImmediate(alarm.fireJS.bind(alarm)) }
+  }
+  return { timeout: setTimeout(alarm.fireJS.bind(alarm), delay) }
+}
+
+globalThis.FAILSclearTimeoutAlarm = (
+  /** @type {{ timeout: string | number | NodeJS.Timeout | undefined; immediate: NodeJS.Immediate | undefined; }} */ obj
+) => {
+  if (obj.timeout) clearTimeout(obj.timeout)
+  if (obj.immediate) clearImmediate(obj.immediate)
+}
+
+function convertToPem(/** @type {ArrayBuffer} */ cert) {
+  return (
+    '-----BEGIN CERTIFICATE-----\n' +
+    Buffer.from(new Uint8Array(cert)).toString('base64') +
+    '\n-----END CERTIFICATE-----\n'
+  )
+}
+
+globalThis.FAILSVerifyProof = (
+  /** @type {{ certs: ArrayBuffer[]; hostname: string; server_config?: string; signature?: string; }} */ obj
+) => {
+  try {
+    console.warn(
+      'Non serverCertificateHashes certificate verification is an experimental feature for webtransport node client and not covered by tests and thus may be broken (DO NOT USE IN PRODUCTION)'
+    )
+    if (obj.certs.length < 1) return false
+    const pem = convertToPem(obj.certs[0])
+    const leafcert = new X509Certificate(pem)
+    if (!leafcert.checkHost(obj.hostname)) return false
+
+    if (obj.server_config) {
+      if (!obj.signature) return false
+      const verify = createVerify('SHA256')
+      verify.write(obj.server_config)
+      verify.end()
+      if (!verify.verify(leafcert.publicKey, obj.signature, 'hex')) return false
+    }
+
+    const curdate = new Date()
+
+    if (
+      new Date(leafcert.validFrom) > curdate ||
+      new Date(leafcert.validTo) < curdate
+    )
+      return false
+
+    let curcert = leafcert
+    for (let certnum = 1; certnum < obj.certs.length; certnum++) {
+      const nextpem = convertToPem(obj.certs[certnum])
+      const nextcert = new X509Certificate(nextpem)
+
+      if (
+        new Date(nextcert.validFrom) > curdate ||
+        new Date(nextcert.validTo) < curdate
+      )
+        return false
+
+      if (!curcert.checkIssued(nextcert)) return false
+      if (!curcert.verify(nextcert.publicKey)) return false
+      curcert = nextcert
+    }
+    // curcert must be one of the rootCertificates
+
+    if (
+      !rootCertificates.some((rootCA) => {
+        const testCert = new X509Certificate(rootCA)
+        if (curcert.checkIssued(testCert)) {
+          if (!curcert.verify(testCert.publicKey)) return false
+          else return true
+        } else return false
+      })
+    )
+      return false
+  } catch (error) {
+    log('VerifyProof error:', error)
+    return false
+  }
+  return true
+}
+
+export class Http3WebTransportSocket {
+  /**
+   * @param {import('../../../main/lib/types.js').HttpWebTransportInit|undefined} args
+   */
+  // eslint-disable-next-line no-unused-vars
+  constructor(args) {
+    /** @type {import('node:dgram').Socket} */
+    // @ts-ignore
+    this.socketInt = undefined // the transport will set this
+    // @ts-ignore
+    this.cobj = undefined // the transport will set this
+    this.chlosSched = false
+    this.packetSendCB = this.packetSendCB.bind(this)
+    this.doProcessBufferedChlos = this.doProcessBufferedChlos.bind(this)
+    this.blocked = false
+    this.closed = false
+  }
+
+  doProcessBufferedChlos() {
+    this.cobj.processBufferedChlos()
+    this.chlosSched = false
+  }
+
+  /**
+   * @param {import('./types').UDPServerSocketSend} args
+   */
+
+  sendPacket({ msg, offset, length, port, address }) {
+    if (this.closed) return true
+    this.socketInt.send(
+      msg, // It seems that we need a copy, so maybe a js side buffer is a better choice, we copy now on c++ side
+      offset,
+      length,
+      port,
+      address,
+      this.packetSendCB
+    )
+    const blocked = this.socketInt.getSendQueueCount() > 0
+    this.blocked = this.blocked || blocked
+    return blocked
+  }
+
+  packetSendCB() {
+    if (
+      !this.closed &&
+      this.socketInt.getSendQueueCount() === 0 &&
+      this.blocked
+    ) {
+      this.cobj.onCanWrite()
+    }
+  }
+}

package/lib/types.ts

@@ -0,0 +1,32 @@
+import type {
+  WebTransportOptions
+} from '../../../main/lib/dom'
+
+export interface UDPServerSocketSend {
+    msg:  Uint8Array
+    offset: number
+    length: number
+    port:number
+    address: string
+  }
+
+  export interface Logger {
+    (formatter: any, ...args: any[]): void
+    error: (formatter: any, ...args: any[]) => void
+    trace: (formatter: any, ...args: any[]) => void
+  }
+
+export type QUICHE_LOG_OFF = -1
+export type QUICHE_LOG_INFO = 0
+export type QUICHE_LOG_WARNING = 1
+export type QUICHE_LOG_ERROR = 2
+export type QUICHE_LOG_FATAL = 3
+export type QUICHE_LOG = QUICHE_LOG_OFF | QUICHE_LOG_INFO | QUICHE_LOG_WARNING | QUICHE_LOG_ERROR | QUICHE_LOG_FATAL
+
+  export interface HttpWebTransportInit extends WebTransportOptions {
+    host: string
+    port: string | number
+    quicheLogVerbose?: QUICHE_LOG
+    forceIpv6?: boolean
+    localPort?: number
+  }

package/lib/utils.js

@@ -0,0 +1,12 @@
+import debug from 'debug'
+
+/**
+ * @param {string} name
+ * @returns {import('./types').Logger}
+ */
+export function logger(name) {
+  return Object.assign(debug(name), {
+    error: debug(`${name}:error`),
+    trace: process?.env.DEBUG_TRACE ? debug(`${name}:trace`) : () => {}
+  })
+}

package/package.json

@@ -1,6 +1,38 @@
 {
   "name": "@10p.io/webtransport-quiche",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "20.73.0",
+  "author": "Nozomu Miyamoto",
+  "description": "@fails-components/webtransport-transport-http3-quiche 1.6.3 that loads webtransport.node from per-platform optionalDependencies (no install script)",
+  "type": "module",
+  "exports": {
+    ".": {
+      "node": "./lib/index.js"
+    }
+  },
+  "license": "BSD-3-Clause",
+  "files": [
+    "lib",
+    "LICENSE",
+    "LICENSE.chromium",
+    "LICENSE.envoy",
+    "README.md"
+  ],
+  "dependencies": {
+    "debug": "^4.3.4"
+  },
+  "optionalDependencies": {
+    "@10p.io/webtransport-quiche-darwin-arm64": "20.73.0",
+    "@10p.io/webtransport-quiche-darwin-x64": "20.73.0",
+    "@10p.io/webtransport-quiche-linux-x64": "20.73.0",
+    "@10p.io/webtransport-quiche-linux-arm64": "20.73.0",
+    "@10p.io/webtransport-quiche-win32-x64": "20.73.0"
+  },
+  "engines": {
+    "node": ">= 20"
+  },
+  "homepage": "https://github.com/nontangent/x_x_machina/tree/develop/packages/@10p.io/webtransport-quiche",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nontangent/x_x_machina.git"
+  }
+}