- Blob support for fetch API (#1070) (56aa96d)
- Fanout update to redirect_to_grip_proxy_v2 passing request handle (#1079) (baf0a6e)
- support --env option for the runtime build (#1090) (e81d252)
- configureConsole function for configuring log prefixing and stderr (#1065) (9ed80ee)
- StarlingMonkey update (#1067) (857f6fa)
- do not throw uninitialized for KV (#1064) (c160c4a)
- KVStore lookup fix for if-generation-match option (#1069) (9e4c795)
- ensure headers are set on first commit (#1036) (d622799)
- fixup compute-file-server-cli dependency build (#1037) (206a60e)
- document AOT optimization flag (#1023) (9ba14cd)
- KV Store v2 (#1004) (fda97cc)
- module mode (#1021) (9e47649)
- default enable allowDynamicBackends with better unsupported errors (#995) (bb858fe)
- setDefaultDynamicBackendConfig with all backend configuration options (#993) (1847924)
- support backend property hostcalls (#1002) (1d9f91a)
- never error for missing client data, return null instead (#979) (7068321)
- null return instead of an error for missing geo data (d4c9b69)
- simple cache getOrSet inner rejections to reject outer promise (#981) (c1fdc49)
- Add support for vcpu ms hostcall (#950) (aea826f)
- expose purgeSurrogateKey hostcall (#953) (4468e3c)
- Device.toJSON() properties (#937) (c4182d3)
- event loop stall error no longer a panic (#934) (08c9934)
- ship --debug-build CLI flag as public (#907) (2728141)
- support getSetCookie on new StarlingMonkey headers implementation (#844) (c102521)
- Add new CLI name of
js-computewhich matches the published package name@fastly/js-compute(#869) (60d1d20)
- core-cache headers case (#889) (3f2db5c)
- ensure we throw an error if FastlyBody.prototype.read is called with a value which is not coercible to a finite positive integer (#877) (1633e02)
- perf: Use wasm-opt -O3 when making a release build (#870) (dd91fa5)
- When constructing an EdgeRateLimiter, retrieve the PenaltyBox instance's name using PenaltyBox::get_name (#866) (9222f1d)
- only time the fetch event when debug logging is enabled (#873) (e4ddf8a)
- re-order the http methods so the most often requested is first and the least requested is last (#874) (6af7626)
- Use MOZ_ASSERT instead of MOZ_RELEASE_ASSERT as these methods are already guarded correctly where they are being called (#876) (f089616)
- Add FetchEvent.server object which contains information about the server which received the incoming HTTP request from the client. (#855) (538ed9c)
- use StarlingMonkey by default, --disable-starlingmonkey flag (#861) (475cdf9)
- Correct Class name for the ClientInfo class (#854) (efb5694)
- correct spelling in CLI error message (#849) (38b558c)
- support for Response.prototype.ip and port via get_addr_dest_ip & get_addr_dest_port (#817) (391b3d8)
- Update to SpiderMonkey v127.0.2 (#826) (5341f67)
- add documentation for the sdkVersion property (29361ad)
- correct the documentation for the fastly:logger module (#834) (2790cb9)
- CLI to allow commands/args in spawnSync() to contain whitespace (#821) (68d77fb)
- debug build & tests (#818) (3d9a8da)
- add out-of-memory callback with stderr log (#805) (a1bd16c)
- Allow early logger initialization (#804) (514d014)
- Fix string formatting for limit-exceeded errors (#802) (56f5214)
- Fix uses of cabi_realloc that were discarding their results (#811) (4e16641)
- dynamic backends clientCertificate with SecretStore fromBytes, rawbytes (#796) (7d2b7b7)
- support default timeout configurations for dynamic backends (#792) (4dfa8d7)
- remove debugging message which got commited (4219a0a)
- Add KVStore.prototype.delete method (578d858)
- Update to SpiderMonkey 124.0.2 (e32632e)
This release includes:
- An optimization for functions that only use
arguments.lengthto avoid allocating theargumentsobject. - An optimization forObject.HasOwnwhich for small numbers of atoms just unrolls the loop.
- Correct type definition for the global BackendConfiguration type - there is no
checkCertificatefield (62fd0ea) - Improve our console.log output for functions (9a97fc1)
- Refactor our async task implementation to be a generic AsyncTask class instead of separate implementations for each async operation (68dfec7)
- update to SpiderMonkey 123.0.1 (#744) (32bf617)
This update brings with it the below changes:
- Performance improvements for
JSON.stringify() - An optimisation for
Object.keys()to take advantage of cached for-in iterators if available. - Optimisations for
Object.assign() - RegExp
vflag support - Improved JSON parsing to help avoid garbage collection time when parsing very large files
- The
String.prototype.isWellFormed()andString.prototype.toWellFormed()methods respectively can be used to check if a string contains well-formed Unicode text (i.e. contains no lone surrogates) and sanitise an ill-formed string to well-formed Unicode text. - The
Object.groupBy()andMap.groupBy()static methods for grouping the elements of an iterable are now supported Date.parse()now accepts several additional date formats:- Year > 9999 for
YYYY-MMM-DDformat (e.g.19999-Jan-01) MMM-DD-YYYY(e.g.Jan-01-1970)- Milliseconds for non-ISO date formats (e.g.
Jan 1 1970 10:00:00.050) - Day of week at the beginning of formats which were being rejected, such as:
Wed, 1970-01-01Wed, 1970-Jan-01
- The day of week does not need to be correct, or a day of week at all; for example,
foo 1970-01-01works. - Numeric dashed dates which do not meet the formal ISO standard are now accepted, including:
"01-12-1999"(month first)"1999-1-5"(single-digit month or day)"10000-01-12"(year > 9999)"99-01-05"or"01-05-99"(2-digit year, year must be >31 if it comes first)"1999-01-05 10:00:00"(space between date and time). These dates will be parsed with behavior typical of other non-ISO dates, such as local time zone and month rollover (April 31 rolls over to May 1 since April 31 doesn’t exist).
- Requirements for characters directly following numbers have been loosened to accept new formats, including:
"DDMonYYYY""Mon.DD.YYYY""DD.Mon.YYYY""YYYY.MM.DD""Mon DD YYYY hh:mmXm"(am/pmdirectly following time)
- Timezone
'Z'is now accepted for non-ISO formats (e.g.Jan 1 1970 10:00Z)
- Year > 9999 for
- Other
Date.parse()fixes:YYYY-M-DDandYYYY-MM-Dare no longer assumed GMT as an ISO dateYYYY-MM-DDwould be.- Milliseconds for all formats are truncated after 3 digits, rather than being rounded.
- The
Promise.withResolvers()static method is now supported. This exposes theresolveandrejectcallback functions in the same scope as the returnedPromise, allowing code that resolves or rejects the promise to be defined after its construction. - The
ArrayBuffer.prototype.transfer()andArrayBuffer.prototype.transferToFixedLength()methods can now be used to transfer ownership of memory from one ArrayBuffer to another. After transfer, the original buffer is detached from its original memory and hence unusable; the state can be checked usingArrayBuffer.prototype.detached.
- Performance improvements for
- correct type definition of Headers.prototype.values() to indicate it returns an IterableIterator<string> (#740) (8959e79)
- add fastly:device module which allows applications to detect a device based on a user-agent (#738) (5274fd5)
- correct title for the CoreCache.transactionLookup documentation page (9892d90)
- Add a EdgeRateLimiter JavaScript Class which enables edge-rate-limiting by utilising a RateCounter and a PenaltyBox instance (#732) (4e81fc7)
- Add a PenaltyBox JavaScript Class which can be used standalone for adding and checking if an entry is in the penalty-box (#731) (bfe1e15)
- Add a RateCounter JavaScript Class which can be used standalone for counting and rate calculations (#730) (0f6036f)
- implement and expose JavaScript classes for Fastly's Compute Core Cache feature set (#566) (94f4038)
- ensure we honor first-byte-timeout and between-bytes-timeout for dynamically registered backends (#719) (2851507)
- If request does not have a static backend defined, return
undefinedfor the Request.prototype.backend getter (#722) (251c037)
- Add
manualFramingHeadersonRequestInitandResponseInit, and addRequest.prototype.setManualFramingHeadersandResponse.prototype.setManualFramingHeaders(#705) - Add
Request.prototype.backendgetter to return the name of the backend assigned to the request (9c750e5) - Allow URL as input on fetch() on TypeScript typings for compat with Node.js (#707) (4f39943)
- Make the underlying KVStore.prototype.get implementation be async (a6a5035)
- Make Response.redirect headers be immutable (3527eaf)
- Return correct error type (TypeError or RangeError instead of Error) in Request and Response methods (4ea7de7)
This release of @fastly/js-compute includes 4 new methods to the Backend class, which enable the Fastly Service to retrieve information about any backend, this is particularly useful for checking if the backend is “healthy”. (#523) (08f816a)
The new methods are:
- Backend.exists(name) - Check whether a backend with the given name exists for the Fastly Service.
- Backend.fromName(name) - Check whether a backend with the given name exists for the Fastly Service and if it does, then returns an instance of Backend for the given name.
- Backend.health(name) - Returns the health of the backend with the given name.
- Backend.prototype.toName() - Return the name for the Backend instance.
- bring back support for build-time env vars (#691) (c044ac4)
- raise an error during wizening for async functions given to addEventListener (#689) (e6747a2)
- improve fetch error messages (58ddb20)
- ensure we throw an error when trying to base64 decode _ via
atob(1b2b2f9)
- add support for ECDSA keys to be used with SubtleCrypto.prototype.sign and SubtleCrypto.prototype.verify (#667) (51bb170)
JavaScript dependencies can now target our JavaScript runtime for Fastly Compute explicitly via the recently added “fastly” WinterCG Runtime Key This release updates our internal bundling system to include this functionality Note: If you are using a custom bundling system for your JavaScript projects and want this functionality, you will need to update/configure your bundling system
- Fix SimpleCache API by reverting host_api implementation of the underlying cache apis (4340375)
- remove unused lines of code from docs for SimpleCache/get.mdx (51fd4af)
- update to latest version of gecko-dev which fixes a bug with the default ecma262 sorting algorithm (#643) (64323e3)
- Add documentation for Request.prototype.clone() (9d12321)
- use spidermonkey version 115 (4a4716d)
- reduce memory usage by caching client getters when they are first called (87ee0cb)
- update to latest url crate which passes some more wpt url tests (f0a42fd)
- Request.prototype.clone - Do not create a body on the new request if the request instance being cloned does not contain a body (5debe80)
- Deprecate SimpleCache.set and recommend SimpleCache.getOrSet as the alternative (bff1bf5)
⚠ BREAKING CHANGE
- Rename SimpleCache.delete to SimpleCache.purge and require purge options to be supplied as the second parameter
We are renaming because "purge" is already a well-known and documented concept for removing content from Fastly's cache.
The new addition of a second argument allows the caller to decide what scope to purge the content from, currently they can choose to purge from all of Fastly ("global") or from the POP that contains the currently executing instance ("pop"). We do not provide a default option right now, in the future we may provide a default option, if we discover a common pattern is being used.
Here is an example of migrating an application using SimpleCache.delete to SimpleCache.purge with the same behaviour:
/// <reference types="@fastly/js-compute" />
import { SimpleCache } from 'fastly:cache';
addEventListener('fetch', event => event.respondWith(app(event)));
async function app(event) {
const url = new URL(event.request.url);
const path = url.pathname;
if (url.searchParams.has('delete')) {
- SimpleCache.delete(path);
+ SimpleCache.purge(path, { scope: "global" });
return new Response(page, { status: 204 });
}
let page = SimpleCache.getOrSet(path, async () => {
return {
value: await render(path),
// Store the page in the cache for 1 minute.
ttl: 60
}
});
return new Response(page, {
headers: {
'content-type': 'text/plain;charset=UTF-8'
}
});
}
async function render(path) {
// expensive/slow function which constructs and returns the contents for a given path
await new Promise(resolve => setTimeout(resolve, 10_000));
return path;
}
- add event.client.tlsCipherOpensslName (49b0c99)
- add event.client.tlsClientCertificate (cf93b62)
- add event.client.tlsClientHello (3d87cb2)
- add event.client.tlsJA3MD5 (2ecf4af)
- add event.client.tlsProtocol (4c91142)
- Rename SimpleCache.delete to SimpleCache.purge and require purge options to be supplied as the second parameter (20113c1)
- implement web performance api (ddfe11e)
- only apply our pipeTo/pipeThrough optimisations to TransformStreams who have no transformers (IdentityStreams). (#556) (a88616c)
- Implement SimpleCache.getOrSet method (a1f4517)
-
add fastly:secret-store types (3805238)
-
update to the latest wizer which brings support for prebuilt linux s390x and aarch64 wizer binaries (69484c2)
- When using implicit backends with https protocol, use the hostname for the sni hostname value to match
fetchbehaviour in browsers and other runtimes (84fb6a2)
- Object Store renamed to KV Store (#476)
We have renamed the ObjectStore class to KVStore, and the module name from fastly:object-store to fastly:kv-store.
You will need to update your code to use the new class name and module name.
Below is the change that would need to be made for the imported module name:
- import { ObjectStore } from 'fastly:object-store';
+ import { KVStore } from 'fastly:kv-store';And this is the change that would need to be made for constructing an instance of the class:
- const store = new ObjectStore('my-store');
+ const store = new KVStore('my-store');Here is a full example of migrating an application from ObjectStore to KVStore:
/// <reference types="@fastly/js-compute" />
- import { ObjectStore } from 'fastly:object-store';
+ import { KVStore } from 'fastly:kv-store';
async function app(event) {
- const files = new ObjectStore('files');
+ const files = new KVStore('files');
await files.put('hello', 'world')
const entry = await files.get('hello')
return new Response(await entry.text())
}
addEventListener("fetch", (event) => event.respondWith(app(event)))- Implement Fanout for JS SDK (5198884)
- Add MD5 support into crypto.subtle.digest (9c8efab)
- implement Response.redirect static method and Response.prototype.redirected getter (1623d74)
- Implement subset of crypto.subtle.importKey which can import a JSONWebKey using RSASSA-PKCS1-v1_5 (b66bf50)
- Implement subset of crypto.subtle.sign which can sign data with a JSONWebKey using RSASSA-PKCS1-v1_5 (800fb66)
- Implement subset of crypto.subtle.verify which can verify a signature with a JSONWebKey using RSASSA-PKCS1-v1_5 (077adfd)
- free
bufif an error has occured (bfa84cc)
- Add high-resolution timing function "fastly.now()" behind feature flag "--enable-experimental-high-resolution-time-methods" (f090838)
- replace tree-sitter with acorn + magic string (08a0695)
- Lower the supported NodeJS version from 18 or greater to only 18 (5cc1cd6)
- When converting a URL to a string, do not add a
?if there are no query string parameters (73cdc27)
- BYOB streams, basic usage, pending WPT (ab97e75)
- Implement subset of crypto.subtle.importKey which can import a JSONWebKey using RSASSA-PKCS1-v1_5 (#472) (110e7f4)
- Implement JS CryptoKey Interface (adb31f7)
- Add documentation for FetchEvent, FetchEvent.prototype.respondWith, and FetchEvent.prototype.waitUntil (78e6d92)
- fix typo in geolocation example (f53a06e)
- support unicode patterns via precompilation (87a0dce)
- implement fastly:secret-store package (cde22e3)
- Remove error codes from external error messaging as these codes are not documented anywhere and subject to change (8f8f0ef)
- allow a downstream response to contain lots of headers with the same name without crashing (ba1f0e6)
- implement Request.prototype.clone (3f3a671)
- add crypto.randomUUID function (2c32b42)
- check that setTimeout/setInterval handler is an object before casting to an object (62476f5)
- ensure retrieving the property definitions of ObjectStoreEntry.prototype.body and ObjectStoreEntry.bodyUsed do not cause panics by ensuring we have a valid entry in their Slots (311b84c)
- error message is latin1, we need to use JS_ReportErrorLatin1 to convert the message from latin1 to UTF8CharsZ, otherwise a panic occurs (f1a22a4)
- implement validation for backend cipher definitions (157be64)
- compute runtime component build (#326)
- Limit to node 16/17/18 as some dependencies do not work on node19 yet (0d48f77)
- Disable JS iterator helpers as the feature is at Stage 3 and we should only enable by default Stage 4 features (c90c145)
- Throw TypeErrors in config-store if supplied with invalid parameters or the config-store does not exist (6b70180)
- Disable JS iterator helpers as the feature is at Stage 3 and we should only enable by default Stage 4 features
- add
allowDynamicBackendsfunction tofastly:experimentalmodule (83a003e) - upgrade from SpiderMonkey 96 to SpiderMonkey 107 (#330)
- when appending headers, if the set-cookie header is set then make sure that each cookie value is sent as a separate set-cookie header to the host (f6cf559)
- implement validation for Dictionary names and keys (c0b0822)
- fix: When streaming a response to the host, do not close the response body if an error occurs (8402ecf)
- add fastly:experimental module which contains all our experimental functions such as includeBytes and enableDebugLogging (5c6a5d7)
- update nodejs supported versions to 16 - 19 and npm supported version to only 8 (5ec70b9)
- add fastly:cache-override module (f433464)
- add geo ip lookup function to fastly:geolocation (24601e5)
- Add Logger constructor to "fastly:logger" module (b4818a2)
- expose fastly loggers via fastly:logger module (2d0bcfe)
- expose the fastly features via 'fastly:' namespaced modules (c06cd16)
- move env function into fastly:env (327b344)
- Add types for setTimeout, clearTimeout, setInterval, clearInterval (c1ed00c)
- Allow process.execPath to contain whitespace (caefe51)
- add missing shebang and executable bit to the binary file (3f0cd69)
- implement setTimeout, setInterval, clearTimeout, and clearInterval (128bca9)
- implement Request.prototype.setCacheKey (457eabe)
- implement support in Response.json/text/arrayBuffer methods for guest provided streams (50cdc44)
- respond with 500 Internal Server Error when an unhandled error has occured and no response has already been sent to the client (e5982d8)
- Add ConfigStore class (#270)
- Add Dynamic Backends support (#250)
- Improved performance when constructing a ObjectStore instance (#272
Note: This feature is disabled by default for Fastly Services. Please contact Fastly Support to request the feature be enabled on the Fastly Services which require Dynamic Backends.
This feature makes it possible to use the standard fetch within JavaScript applications.
Dynamic Backends is a new feature which enables JavaScript applications to dynamically create new backend server definitions without having to deploy a new version of their Fastly Service. These backends function exactly the same as existing backends, and can be configured in all the same ways as existing backends can via the Fastly Service configuration.
By default, Dynamic Backends are disabled within a JavaScript application as it can be a potential avenue for third-party JavaScript code to send requests, potentially including sensitive/secret data, off to destinations that the JavaScript project was not intending, which could be a security issue. To enable Dynamic Backends the application will need to set fastly.allowDynamicBackends is to true.
There are two ways to make use of Dynamic Backends within JavaScript projects:
The first way is by omitting the backend property definition on the Request instance. The JavaScript Runtime will then create a Dynamic Backend definition using default configuration options. This approach is useful for JavaScript applications as it means that a standard fetch call will now be possible, which means libraries that use the standard fetch will begin to work for applications deployed to Fastly.
Below is as an example JavaScript application using the default Dynamic Backend option:
// Enable dynamic backends -- warning, this is potentially dangerous as third-party dependencies could make requests to their own backends, potentially including your sensitive/secret data
fastly.allowDynamicBackends = true;
// For any request, return the fastly homepage -- without defining a backend!
addEventListener("fetch", event => {
event.respondWith(fetch('https://www.fastly.com/'));
});The second way is by creating a new Dynamic Backend using the new Backend class. This approach is useful for JavaScript applications that want to have full control over the configuration of the new backend defintion, such as only allowing TLS 1.3 and disallowing older versions of TLS for requests made to the new backend.
E.G.
// Enable dynamic backends -- warning, this is potentially dangerous as third-party dependencies could make requests to their own backends, potentially including your sensitive/secret data
fastly.allowDynamicBackends = true;
// For any request, return the fastly homepage -- without defining a backend!
addEventListener("fetch", event => {
// We are not defining all the possible fields here, the ones which are not defined will use their default value instead.
const backend = new Backend({
name: 'fastly',
target: 'fastly.com',
hostOverride: "www.fastly.com",
sslMinVersion: 1.3,
sslMaxVersion: 1.3,
sniHostname: "www.fastly.com",
});
event.respondWith(fetch('https://www.fastly.com/', {
backend // Here we are configuring this request to use the newly defined backend from above.
}));
});We have renamed the Dictionary class to ConfigStore, the old name Dictionary still exists but is now deprecated. We recommend replacing Dictionary with ConfigStore in your code to avoid having to migrate in the future when Dictionary is fully removed.
Below is an example application using the ConfigStore class:
async function app(event) {
const store = new ConfigStore('example')
// Retrieve the contents of the 'hello' key
const hello = await store.get('hello')
return new Response(hello)
}
addEventListener("fetch", event => {
event.respondWith(app(event))
})-
CVE-2022-39218: Fixed
Math.randomandcrypto.getRandomValuesmethods to always use sufficiently random values. The previous versions would use a PRNG (pseudorandom number generator) which we would seed with a random value however due to our use of Wizer, the initial value to seed the PRNG was baked-in to the final WebAssembly module meaning the sequence of numbers generated was predictable for that specific WebAssembly module. The new implementations of bothMath.randomandcrypto.getRandomValuesdo not use a PRNG and instead pull random values from WASI (WebAssembly System Interface) libc’srandom_getfunction, which is always a sufficiently random value.An attacker with access to the same WebAssembly module that calls the affected methods could use the fixed seed to predict random numbers generated by these functions. This information could be used to bypass cryptographic security controls, for example to disclose sensitive data encrypted by functions that use these generators.
Developers should update affected modules after applying this patch. Any secrets generated using affected versions should be rotated. Any sensitive ciphertext generated using affected versions should be considered unsafe, e.g. and be deleted or re-generated.
-
Updated the Typescript definitions for the
consolemethods to indicate that they now accept any number of objects. (#258) -
Store the Object-Store key string into a native object to avoid it becoming garbage collected before being used within
ObjectStore.prototype.getorObjectStore.prototype.put((381242)
-
Explicitly declare void as the return type for functions which return nothing - this allows our package to work with typescript's
strict:trueoption (#253) -
Declare ambient types for our npm package instead of exports as we do not yet export anything from the package (#252)
- Removed
type: "module"from the @fastly/js-compute package.json file as the package still usesrequire
- Implemented ObjectStore and ObjectStoreEntry classes for interacting with Fastly ObjectStore (#110)
- add btoa and atob native implementations (#227) (8b8c31f)
This release adds support for Fastly Object-store, which is globally consistent key-value storage accessible across the Fastly Network. This makes it possible for your Fastly Compute application to read and write from Object-stores.
We've added two classes, ObjectStore, and ObjectStoreEntry. ObjectStore is used to interact with a particular Object-store and ObjectStoreEntry is a particular value within an Object-store. We've made ObjectStoreEntry have a similar API as Response to make it simpler to read and write from Object-stores. I.e. ObjectStoreEntry has a body property which is a ReadableStream and has arrayBuffer/json/text methods - just like Response.
The way to use these classes is best shown with an example:
async function app(event) {
// Create a connection the the Object-store named 'example-store'
const store = new ObjectStore('example-store')
// Create or update the 'hello' key with the contents 'world'
await store.put('hello', 'world')
// Retrieve the contents of the 'hello' key
// Note: Object-stores are eventually consistent, this means that the updated contents associated may not be available to read from all
// Fastly edge locations immediately and some edge locations may continue returning the previous contents associated with the key.
const hello = await store.get('hello')
// Read the contents of the `hello` key into a string
const hellotext = await hello.text()
return new Response(hellotext)
}
addEventListener("fetch", event => {
event.respondWith(app(event))
})These two functions enable you to encode to (btoa) and decode from (atob) Base64 strings. They follow the same specification as the atob and btoa functions that exist in web-browsers.
addEventListener("fetch", event => {
event.respondWith(new Response(atob(btoa('hello from fastly'))))
})Previously our console methods only supported a single argument and would convert the argument to a string via String(argument), this unfortunately made it difficult to log out complex objects such as Request objects or similar.
We've updated our console methods and they now support any number of arguments. As well as supporting any number of arguments, we've also changed the implementation to have better support for logging out complex objects.
This is a before and after example of what happens when logging a Request with our console methods.
Before:
const request = new Request('https://www.fastly.com', {body:'I am the body', method: 'POST'});
console.log(request); // outputs `[object Object]`.After:
const request = new Request('https://www.fastly.com', {body:'I am the body', method: 'POST'});
console.log(request); // outputs `Request: {method: POST, url: https://www.fastly.com/, version: 2, headers: {}, body: null, bodyUsed: false}`.- Improved console output for all types (#204)
- Implement the DecompressionStream builtin
#160 - Improve performace of Regular Expression literals via precompilation
#146
- Calling
teeon the client request no longer causes the application to hang#156
- Implement the CompressionStream builtin #84
- Removed the requirement for a fastly.toml file to be present when using js-compute-runtimes CLI to compile a WASM file
- Breaking change: Removed --skip-pkg argument from js-compute-runtime's CLI #108
- Breaking change: Removed
console.tracemethod
- Fix the response error message text
- Throw an error if constructors are called as plain functions
- Fix the behavior of
console.debug - Allow builtin classes to be extended
- Updated the js-compute-runtime to 0.2.5 : Increased max uri length to 8k, and properly forwards http headers to upstream requests even if the headers aren't ever read from
- Support streaming upstream request bodies
- Add full support for TransformStreams
- Support directly piping Request/Response bodies to other Requests/Responses instead of manually copying every chunk
- Add support for the
queueMicrotaskglobal function - Add support for the
structuredCloneglobal function - Add support for the
locationglobal object as an instance ofWorkerLocation - Support BigUint64Array and BigInt64Array in crypto.getRandomValues
- Enable class static blocks syntax
- Returned the exit code from the JS Compute Runtime, by passing it up through our CLI
- Increase max supported header size from 4096 bytes to 69000 bytes
- Update to SpiderMonkey 96 beta
- Avoid waiting for async tasks that weren't passed to
FetchEvent#waitUntil - Significantly improve spec-compliance of Request and Response builtins
- Updated the js-compute-runtime to
0.2.2(Which includes fixes to geoip, a way to get environment variables, improves debugging of exceptions in the request handler, and other updates) - Added the
Envnamespace for accessing Fastly Compute environment variables.
- Implement the WHATWG URL and URLSearchParam classes
- Enable private class fields and methods, plus ergonomic brand checks
- Breaking change: Implement FetchEvent#waitUntil
- Mark builtins that rely on hostcalls as request-handler-only
- Add support for including binary files, and for using typed arrays as Response bodies
- Improve handling of hostcall errors
- Breaking change: Make FetchEvent handling more spec-compliant
- Normalize HTTP method names when constructing Requests
- Don't trap when trying to delete a non-existent header
- Properly support
baseargument inURLconstructor
- Initial Release
- Includes TypeScript type definitions for Fastly Compute flavored ServiceWorkers APIs
- Also includes the
js-compute-runtimeCLI for bundling JavaScript applications