@nimbus-sh/worker 0.6.0 → 0.7.0

package/dist/npm/semver.js

@@ -0,0 +1,226 @@
+/**
+ * npm/semver.ts — the one semver implementation the npm resolver picks
+ * versions with.
+ *
+ * The resolver facet (npm/resolve-one-facet.ts) runs inside a dynamic worker
+ * whose only module scope is the preamble string in
+ * loaders/npm-resolve-preamble.ts. That preamble embeds THESE functions by
+ * `fn.toString()`, so the facet's version pick is this module's by
+ * construction — there is no second copy to drift, and
+ * tests/unit/npm-semver.mjs asserts the embedded functions answer exactly
+ * as the exported ones do.
+ *
+ * Every function here is self-contained on purpose: no closures over module
+ * constants, no imports, only calls to the other functions in this file by
+ * name. `toString()` reproduces exactly that, and nothing else.
+ *
+ * What is implemented is the subset of node-semver that npm dependency
+ * ranges use: exact versions, `^`, `~`, comparators, hyphen ranges, `||`,
+ * X-ranges (`1`, `1.2`, `1.x`, `*`), and — the part the previous helper
+ * lacked — prerelease identifiers. Ignoring them meant every `1.0.0-*`
+ * compared equal, so `json-server@1.0.0-beta.15` resolved to whichever
+ * `1.0.0-*` the packument listed first (`1.0.0-alpha.1`) and
+ * `^1.0.0-next.24` picked `1.0.0-next.0`. Measured against the live registry
+ * lists before this rewrite.
+ */
+/** Parse `v1.2.3-beta.4+build` → `[1, 2, 3, ['beta', 4]]`; null for a non-version. */
+export function parseSemver(v) {
+    const m = String(v).trim().replace(/^[v=]+/, '')
+        .match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
+    if (!m)
+        return null;
+    const prerelease = m[4] === undefined
+        ? []
+        : m[4].split('.').map((id) => (/^\d+$/.test(id) ? Number(id) : id));
+    return [Number(m[1]), Number(m[2]), Number(m[3]), prerelease];
+}
+/**
+ * Total order. A release sorts above every prerelease of the same triple;
+ * prerelease identifiers compare left to right, numeric before alphanumeric,
+ * numeric by value, alphanumeric lexically, and a longer list sorts above
+ * its prefix (semver.org §11).
+ */
+export function compareSemver(a, b) {
+    if (a[0] !== b[0])
+        return a[0] - b[0];
+    if (a[1] !== b[1])
+        return a[1] - b[1];
+    if (a[2] !== b[2])
+        return a[2] - b[2];
+    const ap = a[3] ?? [];
+    const bp = b[3] ?? [];
+    if (ap.length === 0 && bp.length === 0)
+        return 0;
+    if (ap.length === 0)
+        return 1;
+    if (bp.length === 0)
+        return -1;
+    const n = Math.min(ap.length, bp.length);
+    for (let i = 0; i < n; i++) {
+        const x = ap[i];
+        const y = bp[i];
+        if (x === y)
+            continue;
+        if (typeof x === 'number' && typeof y === 'number')
+            return x - y;
+        if (typeof x === 'number')
+            return -1;
+        if (typeof y === 'number')
+            return 1;
+        return x < y ? -1 : 1;
+    }
+    return ap.length - bp.length;
+}
+/**
+ * One comparator set (the space-separated part of a range) as
+ * `>=lower <upper` bounds. Every range shape npm uses normalises to at
+ * most two bounds, so a set is a list of `[op, version]` pairs.
+ */
+export function semverComparators(part) {
+    const comp = part.trim();
+    if (comp === '' || comp === '*' || comp === 'x' || comp === 'X' || comp === 'latest')
+        return [];
+    const m = comp.match(/^(\^|~>?|>=|<=|>|<|=)?\s*v?(\d+|[xX*])(?:\.(\d+|[xX*]))?(?:\.(\d+|[xX*]))?(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
+    if (!m)
+        return null;
+    const op = m[1] === '~>' ? '~' : (m[1] ?? '');
+    const wild = (s) => s === undefined || s === 'x' || s === 'X' || s === '*';
+    const majorWild = wild(m[2]);
+    const minorWild = wild(m[3]);
+    const patchWild = wild(m[4]);
+    const major = majorWild ? 0 : Number(m[2]);
+    const minor = minorWild ? 0 : Number(m[3]);
+    const patch = patchWild ? 0 : Number(m[4]);
+    const pre = m[5] === undefined || patchWild
+        ? []
+        : m[5].split('.').map((id) => (/^\d+$/.test(id) ? Number(id) : id));
+    const lower = [major, minor, patch, pre];
+    const ge = () => [['>=', lower]];
+    const upto = (u) => [['>=', lower], ['<', u]];
+    // X-ranges: `*`, `1`, `1.2`, `1.x`, `1.2.x` — an op in front is applied to
+    // the lowest version the X-range names (`>=1.2` is `>=1.2.0`, `<1.x` is `<1.0.0`).
+    if (majorWild)
+        return [];
+    if (minorWild) {
+        if (op === '' || op === '^' || op === '~' || op === '=')
+            return upto([major + 1, 0, 0, []]);
+        return op === '<=' ? [['<', [major + 1, 0, 0, []]]] : [[op, lower]];
+    }
+    if (patchWild) {
+        if (op === '' || op === '~' || op === '=')
+            return upto([major, minor + 1, 0, []]);
+        if (op === '^')
+            return upto(major === 0 ? [0, minor + 1, 0, []] : [major + 1, 0, 0, []]);
+        return op === '<=' ? [['<', [major, minor + 1, 0, []]]] : [[op, lower]];
+    }
+    switch (op) {
+        case '^':
+            if (major > 0)
+                return upto([major + 1, 0, 0, []]);
+            if (minor > 0)
+                return upto([0, minor + 1, 0, []]);
+            return upto([0, 0, patch + 1, []]);
+        case '~':
+            return upto([major, minor + 1, 0, []]);
+        case '':
+        case '=':
+            return [['=', lower]];
+        default:
+            return [[op, lower]];
+    }
+}
+/**
+ * node-semver's prerelease rule: a prerelease version satisfies a comparator
+ * set only when some comparator in that set names a prerelease of the same
+ * `major.minor.patch`. `^1.0.0-next.24` admits `1.0.0-next.29` and `1.0.0`,
+ * never `1.1.0-rc.1`; `^1.0.0` admits no prerelease at all.
+ */
+export function satisfiesRange(version, range) {
+    const v = parseSemver(version);
+    if (!v)
+        return false;
+    const trimmed = String(range).trim();
+    if (trimmed === '' || trimmed === '*' || trimmed === 'x' || trimmed === 'latest')
+        return v[3].length === 0;
+    for (const orPart of trimmed.split(/\s*\|\|\s*/)) {
+        let comparators = [];
+        const hyphen = orPart.trim().match(/^(\S+)\s+-\s+(\S+)$/);
+        if (hyphen) {
+            const lo = semverComparators('>=' + hyphen[1]);
+            const hi = semverComparators('<=' + hyphen[2]);
+            comparators = lo && hi ? [...lo, ...hi] : null;
+        }
+        else {
+            for (const part of orPart.trim().split(/\s+/)) {
+                const c = semverComparators(part);
+                if (c === null) {
+                    comparators = null;
+                    break;
+                }
+                comparators.push(...c);
+            }
+        }
+        if (comparators === null)
+            continue;
+        let ok = true;
+        for (const [op, r] of comparators) {
+            const cmp = compareSemver(v, r);
+            if (op === '>=' ? cmp < 0 : op === '>' ? cmp <= 0 : op === '<=' ? cmp > 0 : op === '<' ? cmp >= 0 : cmp !== 0) {
+                ok = false;
+                break;
+            }
+        }
+        if (!ok)
+            continue;
+        if (v[3].length > 0) {
+            const admitted = comparators.some(([, r]) => r[3].length > 0 && r[0] === v[0] && r[1] === v[1] && r[2] === v[2]);
+            if (!admitted)
+                continue;
+        }
+        return true;
+    }
+    return false;
+}
+/**
+ * Whether `range` is semver-shaped at all — `''`, `*`, `latest`, tags,
+ * comparators, hyphen ranges, `||` groups. False for git:, github:,
+ * URL, file:, and other non-registry specifiers, where a version pin's
+ * presence is all a lockfile can answer.
+ */
+export function isSemverRange(range) {
+    const trimmed = String(range).trim();
+    if (trimmed === '' || trimmed === '*' || trimmed === 'x' || trimmed === 'X' || trimmed === 'latest')
+        return true;
+    for (const orPart of trimmed.split(/\s*\|\|\s*/)) {
+        const hyphen = orPart.trim().match(/^(\S+)\s+-\s+(\S+)$/);
+        if (hyphen) {
+            const lo = semverComparators('>=' + hyphen[1]);
+            const hi = semverComparators('<=' + hyphen[2]);
+            if (lo === null || hi === null)
+                return false;
+            continue;
+        }
+        for (const part of orPart.trim().split(/\s+/)) {
+            if (semverComparators(part) === null)
+                return false;
+        }
+    }
+    return true;
+}
+/** The highest version satisfying `range`, or null; `latest`/`*` are the caller's dist-tag lookup. */
+export function resolveVersion(versions, range) {
+    const trimmed = String(range ?? '').trim();
+    if (trimmed === '' || trimmed === '*' || trimmed === 'x' || trimmed === 'X' || trimmed === 'latest')
+        return null;
+    let best = null;
+    for (const v of versions) {
+        if (!satisfiesRange(v, trimmed))
+            continue;
+        const p = parseSemver(v);
+        if (!p)
+            continue;
+        if (best === null || compareSemver(p, best.p) > 0)
+            best = { v, p };
+    }
+    return best === null ? null : best.v;
+}

package/dist/router/remote-api.js

@@ -163,30 +163,45 @@ async function dispatchRemoteRpc(ctx) {
             assertRuntimeForLanguage(ctx, language, options.install);
             return ctx.stub._rpcRunCode(stringArg(args[0], 'code'), options);
         }
+        // The file plane. Each op's trailing argument is the SDK's file options
+        // object; `fileOptions` reads it so a `cred` the client put on the wire
+        // is refused loudly rather than dropped — the session-user default is
+        // the only identity a remote token can act as.
         case 'readFile':
+            fileOptions(args[1]);
             return ctx.stub._rpcReadFile(stringArg(args[0], 'path'));
         case 'readFileBytes':
+            fileOptions(args[1]);
             return ctx.stub._rpcReadFileBytes(stringArg(args[0], 'path'));
         case 'writeFile':
+            fileOptions(args[2]);
             return ctx.stub._rpcWriteFile(stringArg(args[0], 'path'), fileContentArg(args[1]));
         case 'stat':
+            fileOptions(args[1]);
             return ctx.stub._rpcStat(stringArg(args[0], 'path'));
         case 'lstat':
+            fileOptions(args[1]);
             return ctx.stub._rpcLstat(stringArg(args[0], 'path'));
         case 'rename':
+            fileOptions(args[2]);
             return ctx.stub._rpcRename(stringArg(args[0], 'from'), stringArg(args[1], 'to'));
         case 'chmod':
+            fileOptions(args[2]);
             return ctx.stub._rpcChmod(stringArg(args[0], 'path'), numberArg(args[1], 'mode'));
         case 'readRange':
+            fileOptions(args[3]);
             return ctx.stub._rpcFsReadRange(stringArg(args[0], 'path'), numberArg(args[1], 'offset'), numberArg(args[2], 'length'));
         case 'readdir':
+            fileOptions(args[1]);
             return ctx.stub._rpcReaddir(stringArg(args[0], 'path'));
         case 'exists':
+            fileOptions(args[1]);
             return ctx.stub._rpcExists(stringArg(args[0], 'path'));
         case 'mkdir':
+            fileOptions(args[1]);
             return ctx.stub._rpcMkdir(stringArg(args[0], 'path'));
         case 'deleteFile':
-            return ctx.stub._rpcDeleteFile(stringArg(args[0], 'path'), objectArg(args[1]));
+            return ctx.stub._rpcDeleteFile(stringArg(args[0], 'path'), fileOptions(args[1]));
         case 'installRuntime': {
             const spec = stringArg(args[0], 'spec');
             assertRuntimeAllowed(ctx, spec, 'onDemand');
@@ -301,6 +316,21 @@ function execOptions(ctx, value) {
         cwd: typeof options.cwd === 'string' ? options.cwd : ctx.root,
     };
 }
+/**
+ * A file op's options object. The same boundary rule as `execOptions`: the
+ * remote token authenticates a SESSION, so a caller does not get to name the
+ * uid its file operation acts as. `files.as(cred)` puts `cred` on the wire
+ * explicitly so this refusal is the answer the caller gets — never a read
+ * that silently ran as somebody else. A colocated embedder holding the DO
+ * stub is trusted with `cred` the same way it is trusted with kernel writes.
+ */
+function fileOptions(value) {
+    const options = value === undefined ? {} : objectArg(value);
+    if (options.cred !== undefined) {
+        throw apiError('cred is not accepted over the remote API', 'E_ARG_SHAPE', 400);
+    }
+    return options;
+}
 function processLogOptions(value) {
     const options = objectArg(value);
     return {

package/dist/runtime/html-entrypoint.d.ts

@@ -3,5 +3,12 @@ export declare function rewriteViteBuildHtml(html: string, options: {
     jsFilename: string;
     cssFilename?: string;
     removeImportMap?: boolean;
+    /**
+     * Vite injects `<link rel="stylesheet">` for CSS bundled through the
+     * entry when index.html declares none (the create-vite template puts
+     * all CSS behind `import './index.css'`). Set true to get that
+     * behavior; when false, only an existing stylesheet link is rewritten.
+     */
+    injectCss?: boolean;
 }): Promise<string>;
 //# sourceMappingURL=html-entrypoint.d.ts.map

package/dist/runtime/html-entrypoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"html-entrypoint.d.ts","sourceRoot":"","sources":["../../src/runtime/html-entrypoint.ts"],"names":[],"mappings":"AAEA,wBAAsB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAcxF;AAED,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE;IACP,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,GACA,OAAO,CAAC,MAAM,CAAC,CA8BjB"}
+{"version":3,"file":"html-entrypoint.d.ts","sourceRoot":"","sources":["../../src/runtime/html-entrypoint.ts"],"names":[],"mappings":"AAEA,wBAAsB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAcxF;AAED,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE;IACP,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,GACA,OAAO,CAAC,MAAM,CAAC,CAkDjB"}

package/dist/runtime/html-entrypoint.js

@@ -18,6 +18,7 @@ export async function findHtmlScriptEntrypoint(html) {
 export async function rewriteViteBuildHtml(html, options) {
     if (typeof HTMLRewriter !== 'function')
         return html;
+    let sawCssLink = false;
     const rewriter = new HTMLRewriter()
         .on('script', {
         element(element) {
@@ -34,16 +35,31 @@ export async function rewriteViteBuildHtml(html, options) {
     })
         .on('link[href]', {
         element(element) {
-            if (!options.cssFilename)
-                return;
             const href = element.getAttribute('href');
             if (!href || !isCssAsset(href))
                 return;
+            sawCssLink = true;
+            if (!options.cssFilename)
+                return;
             element.setAttribute('rel', 'stylesheet');
             element.setAttribute('crossorigin', '');
             element.setAttribute('href', `/assets/${options.cssFilename}`);
         },
     });
+    if (options.injectCss && options.cssFilename) {
+        // element.onEndTag fires at </head> — after every `link[href]` child
+        // has been seen — so the stylesheet lands exactly when the document
+        // declares none, the same condition Vite uses for its emitted <link>.
+        rewriter.on('head', {
+            element(element) {
+                element.onEndTag((end) => {
+                    if (!sawCssLink) {
+                        end.before(`<link rel="stylesheet" crossorigin href="/assets/${options.cssFilename}">`, { html: true });
+                    }
+                });
+            },
+        });
+    }
     return await rewriter.transform(new Response(html)).text();
 }
 function isScriptEntrypoint(src) {

package/dist/runtime/node-runner.d.ts

@@ -82,6 +82,9 @@ export interface RunFreshOpts {
     forceLongRunning?: boolean;
     attachedTty?: boolean;
     bundleProfile?: FacetBundleProfile;
+    /** Shell abort (Ctrl+C): aborting this kills the run through the
+     *  terminator exec registers on the pid. */
+    signal?: AbortSignal;
 }
 /** Dispatch a Node-compatible invocation into a fresh or keyed facet. */
 export declare function runFresh(facetMgr: FacetManager, code: string, opts: RunFreshOpts): Promise<RunFreshResult>;

package/dist/runtime/node-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-runner.d.ts","sourceRoot":"","sources":["../../src/runtime/node-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAmB,MAAM,sBAAsB,CAAC;AAE1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2CAA2C,CAAC;AAEpF;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAO/D;AAoBD,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,mCAAmC;AACnC,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;2CAEuC;IACvC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,aAAa,CAAC,EAAE,kBAAkB,CAAC;CACpC;AAED,yEAAyE;AACzE,wBAAsB,QAAQ,CAC5B,QAAQ,EAAE,YAAY,EACtB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,cAAc,CAAC,CA8EzB"}
+{"version":3,"file":"node-runner.d.ts","sourceRoot":"","sources":["../../src/runtime/node-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAmB,MAAM,sBAAsB,CAAC;AAE1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2CAA2C,CAAC;AAEpF;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAO/D;AAoBD,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,mCAAmC;AACnC,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;2CAEuC;IACvC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,aAAa,CAAC,EAAE,kBAAkB,CAAC;IACnC;gDAC4C;IAC5C,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,yEAAyE;AACzE,wBAAsB,QAAQ,CAC5B,QAAQ,EAAE,YAAY,EACtB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,cAAc,CAAC,CAqFzB"}

package/dist/runtime/node-runner.js

@@ -143,6 +143,13 @@ export async function runFresh(facetMgr, code, opts) {
             longRunning: true,
         };
     }
+    // A server-shaped program that finished during its boot (`--version`,
+    // `--help`, a one-shot run of a CLI that also serves) is an ordinary
+    // completed command: its own exit code, no "started" notice.
+    const finished = facetMgr.processExitCode?.(spawned.pid) ?? null;
+    if (finished !== null) {
+        return { exitCode: finished, stdout: '', stderr: '', longRunning: false };
+    }
     const noticeLine = opts.skipSpawn
         ? ''
         : `\x1b[2m[started (long-running): pid=${spawned.pid} cmd="${command}"]\x1b[0m\n`;

package/dist/runtime/node-shims.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-shims.d.ts","sourceRoot":"","sources":["../../src/runtime/node-shims.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAgDH,wBAAgB,iBAAiB,IAAI,MAAM,CA+vO1C"}
+{"version":3,"file":"node-shims.d.ts","sourceRoot":"","sources":["../../src/runtime/node-shims.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAgDH,wBAAgB,iBAAiB,IAAI,MAAM,CAmhP1C"}