@fastly/compute-js-context 0.3.0

package/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [unreleased]
+
+## [0.3.0] - 2025-10-06
+
+### Changed
+
+- BREAKING: Some identifiers renamed:
+   - `buildEnvironment` -> `buildContextProxy` 
+   - `BuildBindings` -> `ContextProxy`
+   - `EnvBindingsDefs` -> `BindingsDefs`
+
+## [0.2.0] - 2025-10-03
+
+### Added
+
+- Initial public release
+
+[unreleased]: https://github.com/fastly/compute-js-context/compare/v0.3.0...HEAD
+[0.3.0]: https://github.com/fastly/compute-js-context/compare/v0.2.0...v0.3.0
+[0.2.0]: https://github.com/fastly/compute-js-context/releases/tag/v0.2.0

package/LICENSE

@@ -0,0 +1,19 @@
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,157 @@
+# Fastly Compute Context Utility
+
+`@fastly/compute-js-context` exposes Fastly Compute resources to your Compute JavaScript application. It provides it as one typed, immutable context object, or as a custom, strongly-typed object mapping your service's specific resource names to their handles.
+
+## The `Context` Object
+
+The core export is `createContext`, which returns a single, immutable `Context` object.
+
+```ts
+type Context = Readonly<{
+  ACLS: Acls;
+  BACKENDS: Backends;
+  CONFIG_STORES: ConfigStores;
+  ENV: Env;
+  KV_STORES: KVStores;
+  LOGGERS: Loggers;
+  SECRET_STORES: SecretStores;
+}>;
+```
+
+Each top-level field is a [Proxy](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy). Accessing a property lazily looks up and caches the corresponding runtime object. Unknown names return `undefined`.
+
+## Features
+
+- **A single source of truth**: grab everything off `ctx.*`
+- **Typed and safe**: TypeScript-first, with `undefined` for optional resources
+- **Lazy + memoized**: nothing is created until accessed
+- **Readonly**: the `Context` is immutable
+- **Customizable**: use `buildContextProxy` to create a bespoke, typed binding object for your app
+
+## Installation
+
+> Requires a [Fastly Compute JavaScript project (`@fastly/js-compute`)](https://www.fastly.com/documentation/guides/compute/developer-guides/javascript/).
+
+```bash
+npm install @fastly/compute-js-context
+```
+
+## Quick start
+
+This example shows basic usage of the main `Context` object.
+
+```javascript
+/// <reference types="@fastly/js-compute" />
+import { createContext } from '@fastly/compute-js-context';
+
+addEventListener('fetch', (event) => event.respondWith(handler(event)));
+async function handler(event) {
+  const ctx = createContext();
+
+  // Environment - simple strings (or empty string if not present)
+  console.log('FASTLY_SERVICE_VERSION', ctx.ENV.FASTLY_SERVICE_VERSION);
+
+  // Secret Store - property is the SecretStore object, or undefined if not configured
+  const awsSecrets = ctx.SECRET_STORES.AWS_CREDENTIALS;
+  const keyId = await awsSecrets?.get('AWS_ACCESS_KEY_ID');
+  console.log('key id', keyId?.plaintext());
+
+  // Backend - pass to fetch() options, or learn about the backend
+  const origin = ctx.BACKENDS.origin;
+  const res = await fetch("/", { backend: origin });
+
+  // Logger - send output to a named Fastly logging endpoint.
+  const myLogEndpoint = ctx.LOGGERS.my_log_endpoint;
+  myLogEndpoint?.log(`${event.request.url} ${event.client.address}`);
+
+  return new Response("ok");
+}
+```
+
+## Typed Bindings with `buildContextProxy`
+
+For an even better developer experience, `buildContextProxy` creates a typed object that maps your application's specific binding names to the underlying Fastly resources. This gives you shorter names and better autocompletion.
+
+First, define your bindings. The key is the name you want to use, and the value is a string identifying the resource type and (optionally) the resource name if it differs from the key.
+
+Then, pass these definitions to `buildContextProxy()`.
+
+```typescript
+/// <reference types="@fastly/js-compute" />
+import { createContext, buildContextProxy, type BindingsDefs } from '@fastly/compute-js-context';
+
+// Define your application's bindings
+const bindingsDefs = {
+  // Simple mapping: key 'assets' maps to KVStore named 'assets'
+  assets: 'KVStore',
+  
+  // Remapping: key 'origin' maps to Backend named 'origin-s3'
+  origin: 'Backend:origin-s3',
+
+  // Explicit mapping for a logger
+  auditLog: 'Logger:audit_log',
+} satisfies BindingsDefs; // <-- for full type safety
+
+// This is the generated type for your bindings object
+type Bindings = BuildBindings<typeof bindingsDefs>;
+
+addEventListener('fetch', (event) => event.respondWith(handler(event)));
+async function handler(event: FetchEvent): Promise<Response> {
+  const ctx = createContext();
+  
+  // Create the typed environment
+  const bindings: Bindings = buildContextProxy(ctx, bindingsDefs);
+
+  // Now use your custom bindings!
+  const asset = await bindings.assets?.get('/index.html');
+  
+  const res = await fetch("/", { backend: bindings.origin });
+
+  bindings.auditLog?.log('Request received');
+
+  return new Response(asset);
+}
+```
+
+## API
+
+### `createContext(): Context`
+
+Creates the main immutable `Context`. Each sub-object is a `Proxy` that:
+
+- **Resolves lazily** on first property access
+- **Caches** the resolved handle for subsequent accesses
+- **Returns `undefined`** for names that don’t exist (except for `ENV`, which returns `''`)
+- **Is not enumerable** by design (don’t rely on `Object.keys`)
+
+### `buildContextProxy<T>(context: Context, bindingsDefs: T): BuildBindings<T>`
+
+Creates a custom, strongly-typed proxy object based on your definitions.
+
+- `context`: An instance of the main `Context` object
+- `bindingsDefs`: A `const` object defining your desired bindings
+  - **Key**: The property name you want on your final `contextProxy` object
+  - **Value**: A string in the format `'ResourceType'` or `'ResourceType:actual-name'`
+- **Returns**: A proxy object `contextProxy` with your custom bindings. Accessing a property on this object looks up the resource from the main `Context`
+
+### Context Categories & Shapes
+
+> These are the raw shapes available on the main `Context` object.
+
+- **`ENV`**: `Readonly<Record<string, string>>`
+- **`SECRET_STORES`**: `Readonly<Record<string, SecretStore | undefined>>`
+- **`CONFIG_STORES`**: `Readonly<Record<string, ConfigStore | undefined>>`
+- **`KV_STORES`**: `Readonly<Record<string, KVStore | undefined>>`
+- **`BACKENDS`**: `Readonly<Record<string, Backend | undefined>>`
+- **`LOGGERS`**: `Readonly<Record<string, Logger | undefined>>`
+- **`ACLS`**: `Readonly<Record<string, Acl | undefined>>`
+
+## Caveats
+
+- **Don’t enumerate** category proxies; treat them as name-indexed lookups
+- **Don’t mutate** the context or its sub-objects; it’s intentionally `Readonly`
+- **Expect `undefined`** for missing resources and code accordingly (`?.`/guard)
+
+## License
+
+[MIT](./LICENSE).

package/build/acls.d.ts

@@ -0,0 +1,5 @@
+import { Acl } from 'fastly:acl';
+import { type ReadonlyOptionalMap } from "./util.js";
+export type Acls = ReadonlyOptionalMap<Acl>;
+export declare function createAcls(): Acls;
+//# sourceMappingURL=acls.d.ts.map

package/build/acls.js

@@ -0,0 +1,18 @@
+/*
+ * Copyright Fastly, Inc.
+ * Licensed under the MIT license. See LICENSE file for details.
+ */
+import { Acl } from 'fastly:acl';
+import { loadOptionalStringMap } from "./util.js";
+export function createAcls() {
+    return loadOptionalStringMap((name) => {
+        let acl;
+        try {
+            acl = Acl.open(name); // throws if not found or not provisioned
+        }
+        catch {
+            acl = undefined;
+        }
+        return acl;
+    });
+}

package/build/backends.d.ts

@@ -0,0 +1,5 @@
+import { Backend } from 'fastly:backend';
+import { type ReadonlyOptionalMap } from './util.js';
+export type Backends = ReadonlyOptionalMap<Backend>;
+export declare function createBackends(): Backends;
+//# sourceMappingURL=backends.d.ts.map

package/build/backends.js

@@ -0,0 +1,18 @@
+/*
+ * Copyright Fastly, Inc.
+ * Licensed under the MIT license. See LICENSE file for details.
+ */
+import { Backend } from 'fastly:backend';
+import { loadOptionalStringMap } from './util.js';
+export function createBackends() {
+    return loadOptionalStringMap((name) => {
+        let backend;
+        try {
+            backend = Backend.fromName(name); // throws if not found or not provisioned
+        }
+        catch {
+            backend = undefined;
+        }
+        return backend;
+    });
+}

package/build/bindings.d.ts

@@ -0,0 +1,37 @@
+import type { Acl } from 'fastly:acl';
+import type { Backend } from 'fastly:backend';
+import type { ConfigStore } from 'fastly:config-store';
+import type { KVStore } from 'fastly:kv-store';
+import type { Logger } from 'fastly:logger';
+import type { SecretStore } from 'fastly:secret-store';
+import type { Context } from './index.js';
+type Def<T extends string> = T | `${T}:${string}`;
+type Defs<T extends string> = T extends string ? Def<T> : never;
+declare const BindingStringToContextKeyMapping: {
+    readonly Acl: "ACLS";
+    readonly Backend: "BACKENDS";
+    readonly ConfigStore: "CONFIG_STORES";
+    readonly env: "ENV";
+    readonly KVStore: "KV_STORES";
+    readonly Logger: "LOGGERS";
+    readonly SecretStore: "SECRET_STORES";
+};
+export type ResourceType = keyof typeof BindingStringToContextKeyMapping;
+export type BindingsString = Defs<ResourceType>;
+export type EnvBindingsDefs = Record<string, BindingsString>;
+type BindingStringToResourceInstanceTypeMapping = {
+    Acl: Acl;
+    Backend: Backend;
+    ConfigStore: ConfigStore;
+    env: string;
+    KVStore: KVStore;
+    Logger: Logger;
+    SecretStore: SecretStore;
+};
+export type ResourceInstance<T> = T extends Def<infer K extends keyof BindingStringToResourceInstanceTypeMapping> ? BindingStringToResourceInstanceTypeMapping[K] : never;
+export type BuildBindings<T extends EnvBindingsDefs> = {
+    [K in keyof T]: ResourceInstance<T[K]>;
+};
+export declare function buildEnvironment<T extends EnvBindingsDefs>(context: Context, envBindingsDefs: T): BuildBindings<T>;
+export {};
+//# sourceMappingURL=bindings.d.ts.map

package/build/bindings.js

@@ -0,0 +1,52 @@
+const BindingStringToContextKeyMapping = {
+    Acl: 'ACLS',
+    Backend: 'BACKENDS',
+    ConfigStore: 'CONFIG_STORES',
+    env: 'ENV',
+    KVStore: 'KV_STORES',
+    Logger: 'LOGGERS',
+    SecretStore: 'SECRET_STORES',
+};
+function isResourceType(resourceType) {
+    return resourceType in BindingStringToContextKeyMapping;
+}
+function getResourceType(typeName) {
+    const [resourceType,] = typeName.split(':');
+    if (isResourceType(resourceType)) {
+        return resourceType;
+    }
+    return undefined;
+}
+function getResourceName(key, typeName) {
+    const [, seg,] = typeName.split(':');
+    return seg ?? key;
+}
+export function buildEnvironment(context, envBindingsDefs) {
+    const target = {};
+    const getEntry = (key) => {
+        if (typeof key !== "string") {
+            return undefined;
+        }
+        const typeName = envBindingsDefs[key];
+        const resourceType = getResourceType(typeName);
+        if (resourceType == null) {
+            return undefined;
+        }
+        const resourceName = getResourceName(key, typeName);
+        const contextKey = BindingStringToContextKeyMapping[resourceType];
+        const contextEntry = context[contextKey];
+        if (contextEntry == null) {
+            return undefined;
+        }
+        return contextEntry[resourceName];
+    };
+    const handler = {
+        get(_, key) {
+            return getEntry(key);
+        },
+        has(_, key) {
+            return getEntry(key) !== undefined;
+        },
+    };
+    return new Proxy(target, handler);
+}

package/build/config-stores.d.ts

@@ -0,0 +1,5 @@
+import { ConfigStore } from 'fastly:config-store';
+import { type ReadonlyOptionalMap } from './util.js';
+export type ConfigStores = ReadonlyOptionalMap<ConfigStore>;
+export declare function createConfigStores(): ConfigStores;
+//# sourceMappingURL=config-stores.d.ts.map

package/build/config-stores.js

@@ -0,0 +1,18 @@
+/*
+ * Copyright Fastly, Inc.
+ * Licensed under the MIT license. See LICENSE file for details.
+ */
+import { ConfigStore } from 'fastly:config-store';
+import { loadOptionalStringMap } from './util.js';
+export function createConfigStores() {
+    return loadOptionalStringMap((name) => {
+        let configStore;
+        try {
+            configStore = new ConfigStore(name); // throws if not found or not provisioned
+        }
+        catch {
+            configStore = undefined;
+        }
+        return configStore;
+    });
+}

package/build/context.d.ts

@@ -0,0 +1,18 @@
+import { type Acls } from './acls.js';
+import { type Backends } from './backends.js';
+import { type ConfigStores } from './config-stores.js';
+import { type Env } from './env.js';
+import { type KVStores } from './kv-stores.js';
+import { type Loggers } from './loggers.js';
+import { type SecretStores } from './secret-stores.js';
+export type Context = Readonly<{
+    ACLS: Acls;
+    BACKENDS: Backends;
+    CONFIG_STORES: ConfigStores;
+    ENV: Env;
+    KV_STORES: KVStores;
+    LOGGERS: Loggers;
+    SECRET_STORES: SecretStores;
+}>;
+export declare function createContext(): Context;
+//# sourceMappingURL=context.d.ts.map

package/build/context.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright Fastly, Inc.
+ * Licensed under the MIT license. See LICENSE file for details.
+ */
+import { createAcls } from './acls.js';
+import { createBackends } from './backends.js';
+import { createConfigStores } from './config-stores.js';
+import { createEnv } from './env.js';
+import { createKVStores } from './kv-stores.js';
+import { createLoggers } from './loggers.js';
+import { createSecretStores } from './secret-stores.js';
+let _ctx = undefined;
+export function createContext() {
+    if (_ctx === undefined) {
+        _ctx = Object.freeze({
+            ACLS: createAcls(),
+            BACKENDS: createBackends(),
+            CONFIG_STORES: createConfigStores(),
+            ENV: createEnv(),
+            KV_STORES: createKVStores(),
+            LOGGERS: createLoggers(),
+            SECRET_STORES: createSecretStores(),
+        });
+    }
+    return _ctx;
+}

package/build/env.d.ts

@@ -0,0 +1,14 @@
+export type Env = {
+    FASTLY_CACHE_GENERATION?: string;
+    FASTLY_CUSTOMER_ID?: string;
+    FASTLY_HOSTNAME?: string;
+    FASTLY_IS_STAGING?: string;
+    FASTLY_POP?: string;
+    FASTLY_REGION?: string;
+    FASTLY_SERVICE_ID?: string;
+    FASTLY_SERVICE_VERSION?: string;
+    FASTLY_TRACE_ID?: string;
+    [key: string]: string | undefined;
+};
+export declare function createEnv(): Env;
+//# sourceMappingURL=env.d.ts.map

package/build/env.js

@@ -0,0 +1,11 @@
+/*
+ * Copyright Fastly, Inc.
+ * Licensed under the MIT license. See LICENSE file for details.
+ */
+import { env } from 'fastly:env';
+import { loadOptionalStringMap } from './util.js';
+export function createEnv() {
+    return loadOptionalStringMap((name) => {
+        return env(name);
+    });
+}

package/build/index.d.ts

@@ -0,0 +1,3 @@
+export * from './context.js';
+export * from './proxy.js';
+//# sourceMappingURL=index.d.ts.map

package/build/index.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright Fastly, Inc.
+ * Licensed under the MIT license. See LICENSE file for details.
+ */
+export * from './context.js';
+export * from './proxy.js';

package/build/kv-stores.d.ts

@@ -0,0 +1,5 @@
+import { KVStore } from 'fastly:kv-store';
+import { type ReadonlyOptionalMap } from './util.js';
+export type KVStores = ReadonlyOptionalMap<KVStore>;
+export declare function createKVStores(): KVStores;
+//# sourceMappingURL=kv-stores.d.ts.map

package/build/kv-stores.js

@@ -0,0 +1,18 @@
+/*
+ * Copyright Fastly, Inc.
+ * Licensed under the MIT license. See LICENSE file for details.
+ */
+import { KVStore } from 'fastly:kv-store';
+import { loadOptionalStringMap } from './util.js';
+export function createKVStores() {
+    return loadOptionalStringMap((name) => {
+        let kvStore;
+        try {
+            kvStore = new KVStore(name); // throws if not found or not provisioned
+        }
+        catch {
+            kvStore = undefined;
+        }
+        return kvStore;
+    });
+}

package/build/loggers.d.ts

@@ -0,0 +1,5 @@
+import { Logger } from 'fastly:logger';
+import { type ReadonlyOptionalMap } from './util.js';
+export type Loggers = ReadonlyOptionalMap<Logger>;
+export declare function createLoggers(): Loggers;
+//# sourceMappingURL=loggers.d.ts.map

package/build/loggers.js

@@ -0,0 +1,18 @@
+/*
+ * Copyright Fastly, Inc.
+ * Licensed under the MIT license. See LICENSE file for details.
+ */
+import { Logger } from 'fastly:logger';
+import { loadOptionalStringMap } from './util.js';
+export function createLoggers() {
+    return loadOptionalStringMap((name) => {
+        let logger;
+        try {
+            logger = new Logger(name); // throws if not found or not provisioned
+        }
+        catch {
+            logger = undefined;
+        }
+        return logger;
+    });
+}

package/build/proxy.d.ts

@@ -0,0 +1,37 @@
+import type { Acl } from 'fastly:acl';
+import type { Backend } from 'fastly:backend';
+import type { ConfigStore } from 'fastly:config-store';
+import type { KVStore } from 'fastly:kv-store';
+import type { Logger } from 'fastly:logger';
+import type { SecretStore } from 'fastly:secret-store';
+import type { Context } from './index.js';
+type Def<T extends string> = T | `${T}:${string}`;
+type Defs<T extends string> = T extends string ? Def<T> : never;
+declare const BindingStringToContextKeyMapping: {
+    readonly Acl: "ACLS";
+    readonly Backend: "BACKENDS";
+    readonly ConfigStore: "CONFIG_STORES";
+    readonly env: "ENV";
+    readonly KVStore: "KV_STORES";
+    readonly Logger: "LOGGERS";
+    readonly SecretStore: "SECRET_STORES";
+};
+export type ResourceType = keyof typeof BindingStringToContextKeyMapping;
+export type BindingsString = Defs<ResourceType>;
+export type BindingsDefs = Record<string, BindingsString>;
+type BindingStringToResourceInstanceTypeMapping = {
+    Acl: Acl;
+    Backend: Backend;
+    ConfigStore: ConfigStore;
+    env: string;
+    KVStore: KVStore;
+    Logger: Logger;
+    SecretStore: SecretStore;
+};
+export type ResourceInstance<T> = T extends Def<infer K extends keyof BindingStringToResourceInstanceTypeMapping> ? BindingStringToResourceInstanceTypeMapping[K] : never;
+export type ContextProxy<T extends BindingsDefs> = {
+    [K in keyof T]: ResourceInstance<T[K]>;
+};
+export declare function buildContextProxy<T extends BindingsDefs>(context: Context, bindingsDefs: T): ContextProxy<T>;
+export {};
+//# sourceMappingURL=proxy.d.ts.map

package/build/proxy.js

@@ -0,0 +1,56 @@
+/*
+ * Copyright Fastly, Inc.
+ * Licensed under the MIT license. See LICENSE file for details.
+ */
+const BindingStringToContextKeyMapping = {
+    Acl: 'ACLS',
+    Backend: 'BACKENDS',
+    ConfigStore: 'CONFIG_STORES',
+    env: 'ENV',
+    KVStore: 'KV_STORES',
+    Logger: 'LOGGERS',
+    SecretStore: 'SECRET_STORES',
+};
+function isResourceType(resourceType) {
+    return resourceType in BindingStringToContextKeyMapping;
+}
+function getResourceType(typeName) {
+    const [resourceType,] = typeName.split(':');
+    if (isResourceType(resourceType)) {
+        return resourceType;
+    }
+    return undefined;
+}
+function getResourceName(key, typeName) {
+    const [, seg,] = typeName.split(':');
+    return seg ?? key;
+}
+export function buildContextProxy(context, bindingsDefs) {
+    const target = {};
+    const getEntry = (key) => {
+        if (typeof key !== "string") {
+            return undefined;
+        }
+        const typeName = bindingsDefs[key];
+        const resourceType = getResourceType(typeName);
+        if (resourceType == null) {
+            return undefined;
+        }
+        const resourceName = getResourceName(key, typeName);
+        const contextKey = BindingStringToContextKeyMapping[resourceType];
+        const contextEntry = context[contextKey];
+        if (contextEntry == null) {
+            return undefined;
+        }
+        return contextEntry[resourceName];
+    };
+    const handler = {
+        get(_, key) {
+            return getEntry(key);
+        },
+        has(_, key) {
+            return getEntry(key) !== undefined;
+        },
+    };
+    return new Proxy(target, handler);
+}

package/build/secret-stores.d.ts

@@ -0,0 +1,5 @@
+import { SecretStore } from 'fastly:secret-store';
+import { type ReadonlyOptionalMap } from './util.js';
+export type SecretStores = ReadonlyOptionalMap<SecretStore>;
+export declare function createSecretStores(): SecretStores;
+//# sourceMappingURL=secret-stores.d.ts.map

package/build/secret-stores.js

@@ -0,0 +1,18 @@
+/*
+ * Copyright Fastly, Inc.
+ * Licensed under the MIT license. See LICENSE file for details.
+ */
+import { SecretStore } from 'fastly:secret-store';
+import { loadOptionalStringMap } from './util.js';
+export function createSecretStores() {
+    return loadOptionalStringMap((name) => {
+        let secretStore;
+        try {
+            secretStore = new SecretStore(name); // throws if not found or not provisioned
+        }
+        catch {
+            secretStore = undefined;
+        }
+        return secretStore;
+    });
+}

package/build/util.d.ts

@@ -0,0 +1,3 @@
+export type ReadonlyOptionalMap<T> = Readonly<Record<string, T | undefined>>;
+export declare function loadOptionalStringMap<T>(getter: (key: string) => T | undefined): ReadonlyOptionalMap<T>;
+//# sourceMappingURL=util.d.ts.map

package/build/util.js

@@ -0,0 +1,28 @@
+/*
+ * Copyright Fastly, Inc.
+ * Licensed under the MIT license. See LICENSE file for details.
+ */
+export function loadOptionalStringMap(getter) {
+    const cache = new Map();
+    const target = {};
+    const getEntry = (key) => {
+        if (typeof key !== "string") {
+            return undefined;
+        }
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const entry = getter(key);
+        cache.set(key, entry);
+        return entry;
+    };
+    const handler = {
+        get(_, key) {
+            return getEntry(key);
+        },
+        has(_, key) {
+            return getEntry(key) !== undefined;
+        },
+    };
+    return new Proxy(target, handler);
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@fastly/compute-js-context",
+  "version": "0.3.0",
+  "description": "Surfaces Fastly Compute environment as a context object",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fastly/compute-js-context.git"
+  },
+  "author": {
+    "name": "Katsuyuki Omuro",
+    "email": "komuro@fastly.com"
+  },
+  "type": "module",
+  "main": "./build/index.js",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "import": "./build/index.js"
+    }
+  },
+  "types": "./build/index.d.ts",
+  "scripts": {
+    "prepack": "npm run build",
+    "build": "tsc -p tsconfig.build.json",
+    "clean": "rm -rf build"
+  },
+  "devDependencies": {
+    "@fastly/js-compute": "^3.34.0",
+    "typescript": "^5.9.2"
+  },
+  "peerDependencies": {
+    "@fastly/js-compute": "^3.32.0"
+  },
+  "files": [
+    "build/**/*.js",
+    "build/**/*.js.map",
+    "build/**/*.d.ts",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "keywords": [
+    "fastly",
+    "compute",
+    "context"
+  ]
+}