Reflection

The ES6 reflection objects are not available in SSJS. The SFMC server-side JavaScript engine (Jint) implements an ES3/ES5-era dialect and predates ES2015, so Proxy and Reflect are entirely absent. Reflect is undefined, and new Proxy(target, handler) throws Unknown type: Proxy.

Status legend

Icon	Meaning
❌ Missing	Not available (`typeof` is `"undefined"`)

Members

Member	ES	Status	Notes
`Proxy`	ES6	❌ Missing	No trap-based interception
`Reflect`	ES6	❌ Missing	Use ES5 `Object` methods instead

Proxy

(ES6) — ❌ Missing. Proxy is not defined — typeof Proxy === "undefined" and new Proxy({}, {}) throws Unknown type: Proxy. There is no way to intercept property access, assignment, or function calls with traps. Wrap objects in explicit accessor functions when you need mediated access.

Show test script

<script runat="server">
Platform.Load("core", "1.1.5");

/*
 * Chapter: Proxy
 *
 * Proves:
 *   1. DEVIATION from ECMAScript 2015 marked "DEV": Proxy is not defined —
 *      typeof Proxy is "undefined" (spec: "function").
 *   2. Reading a member of the missing global is safe and yields undefined;
 *      only INVOCATION throws.
 *   3. Both invocation forms throw with the documented shapes:
 *        new Proxy({}, {}) -> "Unknown type: Proxy"
 *        Proxy({}, {})     -> "Object expected: Proxy"
 *   4. The documented replacement — wrapping the object in explicit accessor
 *      functions — really does mediate reads and writes.
 *
 * EXPECTED OUTPUT: every line starts with PASS. A FAIL means the runtime no
 * longer matches the documented claim and the page must be revised.
 */

function assert(id, fn, expected) {
    var got;
    try { got = fn(); } catch (ex) { got = "THREW: " + ex.message; }
    Platform.Response.Write((got === expected ? "PASS " : "FAIL ") + id + " -> [" + got + "]\n");
}
function assertThrows(id, fn, expectedMsg) {
    var msg;
    try { fn(); msg = "did NOT throw"; } catch (ex) { msg = ex.message; }
    Platform.Response.Write((msg === expectedMsg ? "PASS " : "FAIL ") + id + " -> [" + msg + "]\n");
}

/* 1. DEVIATION — the global is absent. */
assert("DEV typeof Proxy is undefined (spec: function)", function () { return String(typeof Proxy); }, "undefined");

/* 2. Reading a member of the missing global does not throw. */
assert("reading Proxy.prototype is safe and undefined", function () { return String(typeof Proxy.prototype); }, "undefined");
assert("reading Proxy.revocable is safe and undefined", function () { return String(typeof Proxy.revocable); }, "undefined");

/* 3. Only invocation throws — two distinct message shapes. */
assertThrows("new Proxy({}, {}) throws Unknown type: Proxy", function () { return new Proxy({}, {}); }, "Unknown type: Proxy");
assertThrows("Proxy({}, {}) throws Object expected: Proxy", function () { return Proxy({}, {}); }, "Object expected: Proxy");

/* 4. Workaround — explicit accessor functions instead of traps. */
var target = { id: 42 };
var reads = 0;
function getProp(o, k) { reads = reads + 1; return o[k]; }
function setProp(o, k, v) { o[k] = v; return o[k]; }
assert("workaround accessor reads the property", function () { return String(getProp(target, "id")); }, "42");
assert("workaround accessor counted the read", function () { return String(reads); }, "1");
assert("workaround accessor writes the property", function () { return String(setProp(target, "id", 7)); }, "7");
assert("the write is visible on the target", function () { return String(target.id); }, "7");
</script>

Reflect

(ES6) — ❌ Missing. Reflect is not defined — typeof Reflect === "undefined". Use the ES5 equivalents on Object and direct operators instead:

`Reflect` method	ES5 / operator equivalent
`Reflect.has(o, k)`	`typeof o[k] != "undefined"` — not `k in o`, see below
`Reflect.get(o, k)`	`o[k]`
`Reflect.set(o, k, v)`	`o[k] = v`
`Reflect.deleteProperty(o, k)`	`delete o[k]`
`Reflect.ownKeys(o)`	`Object.keys(o)` (string keys only; no symbols)
`Reflect.getPrototypeOf(o)`	`Object.getPrototypeOf(o)`

Do not substitute the in operator for Reflect.has — it is broken in this engine. Its result has typeof "undefined" (neither === true nor === false), and as an if condition it reports an absent key on an empty object as present. See The in Operator Is Unreliable.

// Instead of Reflect.has(obj, "id"):
var obj = { id: 42 };
Write(typeof obj["id"] != "undefined" ? "has id" : "no id"); // "has id"