diff --git a/package.json b/package.json
index 378a1a696e..06c1a05fa0 100644
--- a/package.json
+++ b/package.json
@@ -40,6 +40,7 @@
     "@dnd-kit/sortable": "^10.0.0",
     "@dnd-kit/utilities": "^3.2.2",
     "@mantine/hooks": "^9.0.0",
+    "@monaco-editor/react": "^4.7.0",
     "@octokit/rest": "^22.0.0",
     "@reduxjs/toolkit": "^1.9.7",
     "@sentry/react": "^10.5.0",
@@ -77,6 +78,7 @@
     "lz-string": "^1.4.4",
     "mdast-util-from-markdown": "^2.0.0",
     "mdast-util-to-hast": "^13.0.0",
+    "monaco-editor": "^0.55.1",
     "normalize.css": "^8.0.1",
     "phaser": "~3.90.0",
     "query-string": "^9.0.0",
diff --git a/src/commons/editor/EditorContainer.test.tsx b/src/commons/editor/EditorContainer.test.tsx
new file mode 100644
index 0000000000..95788e6280
--- /dev/null
+++ b/src/commons/editor/EditorContainer.test.tsx
@@ -0,0 +1,98 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import { Provider } from 'react-redux';
+import { mockInitialStore } from 'src/commons/mocks/StoreMocks';
+import {
+  defaultWorkspaceSettings,
+  WorkspaceSettingsContext,
+} from 'src/commons/WorkspaceSettingsContext';
+import { flagMonacoEditorEnable } from 'src/features/monaco/flagMonacoEditorEnable';
+import { expect, test, vi } from 'vitest';
+
+import EditorContainer, { type EditorContainerProps } from './EditorContainer';
+
+vi.mock('./MonacoEditor', () => ({
+  default: (props: any) => (
+    <textarea
+      data-testid="MonacoEditorMock"
+      onChange={event => props.handleEditorValueChange(props.editorTabIndex, event.target.value)}
+      readOnly={props.sessionDetails?.readOnly ?? false}
+      value={props.editorValue}
+    />
+  ),
+}));
+
+const createProps = (overrides: Partial<EditorContainerProps> = {}): EditorContainerProps => ({
+  activeEditorTabIndex: 0,
+  editorSessionId: '',
+  editorTabs: [
+    {
+      breakpoints: [],
+      editorTabIndex: 0,
+      editorValue: 'const x = 1;',
+      filePath: '/program.js',
+      highlightedLines: [],
+    },
+  ],
+  editorVariant: 'normal',
+  handleDeclarationNavigate: () => {},
+  handleEditorEval: () => {},
+  handleEditorUpdateBreakpoints: () => {},
+  handleEditorValueChange: () => {},
+  handlePromptAutocomplete: () => {},
+  isEditorAutorun: false,
+  isFolderModeEnabled: false,
+  removeEditorTabByIndex: () => {},
+  sessionDetails: null,
+  setActiveEditorTabIndex: () => {},
+  ...overrides,
+});
+
+const renderEditorContainer = (
+  props: EditorContainerProps,
+  featureFlags: Record<string, any> = {},
+) => {
+  const store = mockInitialStore({
+    featureFlags: {
+      modifiedFlags: featureFlags,
+    },
+  });
+
+  return render(
+    <Provider store={store}>
+      <WorkspaceSettingsContext.Provider value={[defaultWorkspaceSettings, () => {}]}>
+        <EditorContainer {...props} />
+      </WorkspaceSettingsContext.Provider>
+    </Provider>,
+  );
+};
+
+test('EditorContainer renders Ace editor path when Monaco flag is off', () => {
+  renderEditorContainer(createProps());
+  expect(screen.getByTestId('Editor')).toBeTruthy();
+  expect(screen.queryByTestId('MonacoEditorMock')).toBeNull();
+});
+
+test('EditorContainer renders Monaco editor path when Monaco flag is on', async () => {
+  renderEditorContainer(createProps(), {
+    [flagMonacoEditorEnable.flagName]: true,
+  });
+  expect(await screen.findByTestId('MonacoEditorMock')).toBeTruthy();
+});
+
+test('Monaco editor path forwards value changes with the active editor tab index', async () => {
+  const handleEditorValueChange = vi.fn();
+  renderEditorContainer(
+    createProps({
+      handleEditorValueChange,
+    }),
+    {
+      [flagMonacoEditorEnable.flagName]: true,
+    },
+  );
+
+  fireEvent.change(await screen.findByTestId('MonacoEditorMock'), {
+    target: { value: 'const y = 2;' },
+  });
+
+  expect(handleEditorValueChange).toHaveBeenCalledWith(0, 'const y = 2;');
+});
diff --git a/src/commons/editor/EditorContainer.tsx b/src/commons/editor/EditorContainer.tsx
index 09f2f05d21..1b8b551597 100644
--- a/src/commons/editor/EditorContainer.tsx
+++ b/src/commons/editor/EditorContainer.tsx
@@ -1,11 +1,15 @@
 import _ from 'lodash';
-import { useContext } from 'react';
+import { lazy, Suspense, useContext } from 'react';
+import { flagMonacoEditorEnable } from 'src/features/monaco/flagMonacoEditorEnable';
 
+import { useFeature } from '../featureFlags/useFeature';
 import type { EditorTabState } from '../workspace/WorkspaceTypes';
 import { WorkspaceSettingsContext } from '../WorkspaceSettingsContext';
 import Editor, { type EditorProps, type EditorTabStateProps } from './Editor';
 import EditorTabContainer from './tabs/EditorTabContainer';
 
+const MonacoEditor = lazy(() => import('./MonacoEditor'));
+
 type OwnProps = {
   baseFilePath?: string;
   isFolderModeEnabled: boolean;
@@ -34,14 +38,22 @@ export const convertEditorTabStateToProps = (
 };
 
 const createNormalEditorTab =
-  (editorProps: Omit<EditorProps, keyof EditorTabStateProps>) =>
+  (editorProps: Omit<EditorProps, keyof EditorTabStateProps>, useMonacoEditor: boolean) =>
   // eslint-disable-next-line react/display-name
   (editorTabStateProps: EditorTabStateProps) => {
-    return <Editor {...editorProps} {...editorTabStateProps} />;
+    const editorPropsWithTab = { ...editorProps, ...editorTabStateProps };
+    return useMonacoEditor ? (
+      <Suspense fallback={null}>
+        <MonacoEditor {...editorPropsWithTab} />
+      </Suspense>
+    ) : (
+      <Editor {...editorPropsWithTab} />
+    );
   };
 
 const EditorContainer: React.FC<EditorContainerProps> = (props: EditorContainerProps) => {
   const [workspaceSettings] = useContext(WorkspaceSettingsContext)!;
+  const useMonacoEditor = useFeature(flagMonacoEditorEnable);
   const {
     baseFilePath,
     isFolderModeEnabled,
@@ -53,7 +65,7 @@ const EditorContainer: React.FC<EditorContainerProps> = (props: EditorContainerP
   } = props;
   editorProps.editorBinding = workspaceSettings.editorBinding;
 
-  const createEditorTab = createNormalEditorTab(editorProps);
+  const createEditorTab = createNormalEditorTab(editorProps, useMonacoEditor);
 
   if (activeEditorTabIndex === null) {
     return (
diff --git a/src/commons/editor/MonacoEditor.test.tsx b/src/commons/editor/MonacoEditor.test.tsx
new file mode 100644
index 0000000000..2e4e3bb742
--- /dev/null
+++ b/src/commons/editor/MonacoEditor.test.tsx
@@ -0,0 +1,90 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import { expect, test, vi } from 'vitest';
+
+import type { EditorProps } from './Editor';
+import MonacoEditor from './MonacoEditor';
+
+vi.mock('monaco-editor', () => ({
+  editor: {
+    defineTheme: vi.fn(),
+  },
+}));
+
+vi.mock('@monaco-editor/react', () => ({
+  default: (props: any) => (
+    <textarea
+      data-theme={props.theme}
+      data-testid="MonacoReactEditorMock"
+      onChange={event => props.onChange(event.target.value, { source: 'test' })}
+      readOnly={props.options?.readOnly ?? false}
+      value={props.value}
+    />
+  ),
+  loader: {
+    config: vi.fn(),
+  },
+}));
+
+const createProps = (overrides: Partial<EditorProps> = {}): EditorProps => ({
+  breakpoints: [],
+  editorSessionId: '',
+  editorTabIndex: 0,
+  editorValue: 'const x = 1;',
+  handleDeclarationNavigate: () => {},
+  handleEditorEval: () => {},
+  handleEditorUpdateBreakpoints: () => {},
+  handleEditorValueChange: () => {},
+  handlePromptAutocomplete: () => {},
+  highlightedLines: [],
+  isEditorAutorun: false,
+  sessionDetails: null,
+  ...overrides,
+});
+
+test('MonacoEditor renders the Monaco React editor wrapper', () => {
+  render(<MonacoEditor {...createProps()} />);
+  const editor = screen.getByTestId('MonacoReactEditorMock') as HTMLTextAreaElement;
+  expect(screen.getByTestId('Editor')).toBeTruthy();
+  expect(editor.value).toBe('const x = 1;');
+  expect(editor.dataset.theme).toBe('source');
+});
+
+test('MonacoEditor forwards changes to workspace handlers', () => {
+  const handleEditorValueChange = vi.fn();
+  const handleUpdateHasUnsavedChanges = vi.fn();
+  const onChange = vi.fn();
+
+  render(
+    <MonacoEditor
+      {...createProps({
+        handleEditorValueChange,
+        handleUpdateHasUnsavedChanges,
+        onChange,
+      })}
+    />,
+  );
+
+  fireEvent.change(screen.getByTestId('MonacoReactEditorMock'), {
+    target: { value: 'const y = 2;' },
+  });
+
+  expect(handleEditorValueChange).toHaveBeenCalledWith(0, 'const y = 2;');
+  expect(handleUpdateHasUnsavedChanges).toHaveBeenCalledWith(true);
+  expect(onChange).toHaveBeenCalledWith('const y = 2;', { source: 'test' });
+});
+
+test('MonacoEditor passes session readonly state to Monaco', () => {
+  render(
+    <MonacoEditor
+      {...createProps({
+        sessionDetails: {
+          docId: 'doc-id',
+          owner: false,
+          readOnly: true,
+        },
+      })}
+    />,
+  );
+
+  expect(screen.getByTestId('MonacoReactEditorMock').hasAttribute('readonly')).toBe(true);
+});
diff --git a/src/commons/editor/MonacoEditor.tsx b/src/commons/editor/MonacoEditor.tsx
new file mode 100644
index 0000000000..7c2dd961e7
--- /dev/null
+++ b/src/commons/editor/MonacoEditor.tsx
@@ -0,0 +1,73 @@
+import { Card } from '@blueprintjs/core';
+import MonacoReactEditor from '@monaco-editor/react';
+import { useCallback } from 'react';
+
+import { EditorProps } from './Editor';
+import { SOURCE_MONACO_THEME } from './monaco/setupMonaco';
+
+const languageByExtension: Record<string, string> = {
+  c: 'c',
+  cc: 'cpp',
+  cpp: 'cpp',
+  css: 'css',
+  h: 'cpp',
+  html: 'html',
+  java: 'java',
+  js: 'javascript',
+  json: 'json',
+  jsx: 'javascript',
+  py: 'python',
+  ts: 'typescript',
+  tsx: 'typescript',
+};
+
+const getLanguage = ({ filePath, mode }: Pick<EditorProps, 'filePath' | 'mode'>): string => {
+  if (mode) {
+    return mode;
+  }
+  const extension = filePath?.split('.').pop()?.toLowerCase();
+  return (extension && languageByExtension[extension]) || 'javascript';
+};
+
+const MonacoEditor: React.FC<EditorProps> = props => {
+  const handleChange = useCallback(
+    (value: string | undefined, event: unknown) => {
+      const newValue = value ?? '';
+      props.handleEditorValueChange(props.editorTabIndex, newValue);
+      props.handleUpdateHasUnsavedChanges?.(true);
+      props.onChange?.(newValue, event);
+    },
+    [props],
+  );
+
+  return (
+    <Card className="Editor">
+      <div className="row editor-react-ace" data-testid="Editor" id="editor-react-ace">
+        <MonacoReactEditor
+          className="react-ace"
+          height="100%"
+          language={getLanguage(props)}
+          onChange={handleChange}
+          options={{
+            fontFamily: "'Inconsolata', 'Consolas', monospace",
+            fontSize: 17,
+            folding: false,
+            glyphMargin: false,
+            hover: { enabled: false },
+            lineHeight: 17,
+            lineNumbersMinChars: 4,
+            minimap: { enabled: false },
+            readOnly: props.sessionDetails?.readOnly ?? false,
+            renderLineHighlight: 'none',
+            scrollBeyondLastLine: false,
+          }}
+          theme={SOURCE_MONACO_THEME}
+          value={props.editorValue}
+          width="100%"
+        />
+      </div>
+    </Card>
+  );
+};
+
+export default MonacoEditor;
diff --git a/src/commons/editor/monaco/setupMonaco.ts b/src/commons/editor/monaco/setupMonaco.ts
new file mode 100644
index 0000000000..3e92c2eb44
--- /dev/null
+++ b/src/commons/editor/monaco/setupMonaco.ts
@@ -0,0 +1,88 @@
+import { loader } from '@monaco-editor/react';
+import * as monaco from 'monaco-editor';
+
+export const SOURCE_MONACO_THEME = 'source';
+
+const aceSourceColors = {
+  activeLineBackground: '#00000059',
+  autocompleteActiveLineBackground: '#495A6B',
+  autocompleteBackground: '#2C3E50',
+  bracketMatchBackground: '#009900',
+  cursor: '#FFFFFF',
+  // These are the visible Ace editor surface colors from _workspace.scss.
+  editorBackground: '#2C3E50',
+  foreground: '#FFFFFF',
+  gutterBackground: '#34495E',
+  invisibleForeground: '#FFFFFF26',
+  lineNumberForeground: '#8091A0',
+  printMarginBackground: '#555555',
+  selectionBackground: '#B36539BF',
+  widgetBorder: '#555555',
+} as const;
+
+type MonacoEnvironmentGlobal = typeof globalThis & {
+  MonacoEnvironment?: {
+    getWorker: (_moduleId: string, label: string) => Worker;
+  };
+};
+
+(self as MonacoEnvironmentGlobal).MonacoEnvironment = {
+  getWorker: () => {
+    return new Worker(new URL('monaco-editor/esm/vs/editor/editor.worker.js', import.meta.url), {
+      type: 'module',
+    });
+  },
+};
+
+const sourceTheme: monaco.editor.IStandaloneThemeData = {
+  base: 'vs-dark',
+  inherit: true,
+  rules: [
+    { token: '', foreground: aceSourceColors.foreground.slice(1) },
+    { token: 'comment', foreground: '0088FF', fontStyle: 'italic' },
+    { token: 'constant', foreground: 'FF628C' },
+    { token: 'keyword', foreground: 'FF9D00' },
+    { token: 'number', foreground: 'FF628C' },
+    { token: 'string', foreground: 'FF628C' },
+    { token: 'type', foreground: 'FFEE80' },
+    { token: 'variable', foreground: 'CCCCCC' },
+  ],
+  colors: {
+    'editor.background': aceSourceColors.editorBackground,
+    'editor.foreground': aceSourceColors.foreground,
+    'editorCursor.foreground': aceSourceColors.cursor,
+    'editorGutter.background': aceSourceColors.gutterBackground,
+    'editorLineNumber.foreground': aceSourceColors.lineNumberForeground,
+    'editorLineNumber.activeForeground': '#C8E4FD',
+    'editor.selectionBackground': aceSourceColors.selectionBackground,
+    'editor.wordHighlightBorder': aceSourceColors.selectionBackground,
+    'editor.lineHighlightBackground': aceSourceColors.activeLineBackground,
+    'editor.lineHighlightBorder': '#00000000',
+    'editorRuler.foreground': aceSourceColors.printMarginBackground,
+    'editorWhitespace.foreground': aceSourceColors.invisibleForeground,
+    'editorIndentGuide.background1': '#334A60',
+    'editorIndentGuide.activeBackground1': aceSourceColors.lineNumberForeground,
+    'editorBracketMatch.background': aceSourceColors.bracketMatchBackground,
+    'editorBracketMatch.border': aceSourceColors.bracketMatchBackground,
+    'editorWidget.background': aceSourceColors.autocompleteBackground,
+    'editorWidget.border': aceSourceColors.widgetBorder,
+    'editorHoverWidget.background': aceSourceColors.autocompleteActiveLineBackground,
+    'editorHoverWidget.border': aceSourceColors.widgetBorder,
+    'editorSuggestWidget.background': aceSourceColors.autocompleteBackground,
+    'editorSuggestWidget.border': aceSourceColors.widgetBorder,
+    'editorSuggestWidget.foreground': aceSourceColors.foreground,
+    'editorSuggestWidget.highlightForeground': '#FF9D00',
+    'editorSuggestWidget.selectedBackground': aceSourceColors.autocompleteActiveLineBackground,
+    'editorSuggestWidget.selectedForeground': aceSourceColors.foreground,
+    'editorSuggestWidget.focusHighlightForeground': '#FF9D00',
+    'editorSuggestWidgetStatus.foreground': '#CED9E0',
+    'scrollbarSlider.background': '#6B839A66',
+    'scrollbarSlider.hoverBackground': '#6B839A99',
+    'scrollbarSlider.activeBackground': '#6B839ACC',
+  },
+};
+
+monaco.editor.defineTheme(SOURCE_MONACO_THEME, sourceTheme);
+monaco.editor.setTheme(SOURCE_MONACO_THEME);
+
+loader.config({ monaco });
diff --git a/src/commons/featureFlags/publicFlags.ts b/src/commons/featureFlags/publicFlags.ts
index ec0169df04..9919e85a81 100644
--- a/src/commons/featureFlags/publicFlags.ts
+++ b/src/commons/featureFlags/publicFlags.ts
@@ -1,10 +1,12 @@
 import { flagConductorEnable } from '../../features/conductor/flagConductorEnable';
 import { flagDirectoryLanguageUrl } from '../../features/directory/flagDirectoryLanguageUrl';
 import { flagDirectoryPluginUrl } from '../../features/directory/flagDirectoryPluginUrl';
+import { flagMonacoEditorEnable } from '../../features/monaco/flagMonacoEditorEnable';
 import { FeatureFlag } from './FeatureFlag';
 
 export const publicFlags: FeatureFlag<any>[] = [
   flagConductorEnable,
   flagDirectoryLanguageUrl,
   flagDirectoryPluginUrl,
+  flagMonacoEditorEnable,
 ];
diff --git a/src/features/monaco/flagMonacoEditorEnable.ts b/src/features/monaco/flagMonacoEditorEnable.ts
new file mode 100644
index 0000000000..ddf3e149c2
--- /dev/null
+++ b/src/features/monaco/flagMonacoEditorEnable.ts
@@ -0,0 +1,10 @@
+import { createFeatureFlag } from '../../commons/featureFlags';
+import { featureSelector } from '../../commons/featureFlags/featureSelector';
+
+export const flagMonacoEditorEnable = createFeatureFlag(
+  'monaco.editor.enable',
+  false,
+  'Enables the Monaco editor shell in place of Ace.',
+);
+
+export const selectMonacoEditorEnable = featureSelector(flagMonacoEditorEnable);
diff --git a/src/styles/_workspace.scss b/src/styles/_workspace.scss
index f55c293a88..26eb873f2f 100644
--- a/src/styles/_workspace.scss
+++ b/src/styles/_workspace.scss
@@ -157,6 +157,10 @@ $code-color-notification: #f9f0d7;
       margin-left: -10px;
       color: red;
     }
+
+    .monaco-editor .lines-content {
+      padding-left: 5px;
+    }
   }
 
   .MCQChooser {
diff --git a/yarn.lock b/yarn.lock
index 0a839d90d1..b5bfd4af65 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2135,6 +2135,28 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@monaco-editor/loader@npm:^1.5.0":
+  version: 1.7.0
+  resolution: "@monaco-editor/loader@npm:1.7.0"
+  dependencies:
+    state-local: "npm:^1.0.6"
+  checksum: 10c0/1fd3579cb09b669493cf553dfc0723a93483140a44353ce9a739827edfa7b2c6541b254024d15c48176ece749ef666b6d16cce6cf0e4396c7fa1c5a48012d08a
+  languageName: node
+  linkType: hard
+
+"@monaco-editor/react@npm:^4.7.0":
+  version: 4.7.0
+  resolution: "@monaco-editor/react@npm:4.7.0"
+  dependencies:
+    "@monaco-editor/loader": "npm:^1.5.0"
+  peerDependencies:
+    monaco-editor: ">= 0.25.0 < 1"
+    react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
+    react-dom: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
+  checksum: 10c0/a4e91c6eda1a71f5fd23871bd801de435490ccbc43934d23cba65cefe2be7e9d02c9a57c4ef80fc9fe99e4d4deea51e5db19cb4e0ecf3f51818dda0eb9cdbf12
+  languageName: node
+  linkType: hard
+
 "@napi-rs/wasm-runtime@npm:1.1.4, @napi-rs/wasm-runtime@npm:^1.1.4":
   version: 1.1.4
   resolution: "@napi-rs/wasm-runtime@npm:1.1.4"
@@ -6153,6 +6175,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"dompurify@npm:3.2.7":
+  version: 3.2.7
+  resolution: "dompurify@npm:3.2.7"
+  dependencies:
+    "@types/trusted-types": "npm:^2.0.7"
+  dependenciesMeta:
+    "@types/trusted-types":
+      optional: true
+  checksum: 10c0/d41bb31a72f1acdf9b84c56723c549924b05d92a39a15bd8c40bec9007ff80d5fccf844bc53ee12af5b69044f9a7ce24a1e71c267a4f49cf38711379ed8c1363
+  languageName: node
+  linkType: hard
+
 "dompurify@npm:^3.2.4":
   version: 3.4.2
   resolution: "dompurify@npm:3.4.2"
@@ -7069,6 +7103,7 @@ __metadata:
     "@dnd-kit/sortable": "npm:^10.0.0"
     "@dnd-kit/utilities": "npm:^3.2.2"
     "@mantine/hooks": "npm:^9.0.0"
+    "@monaco-editor/react": "npm:^4.7.0"
     "@octokit/rest": "npm:^22.0.0"
     "@reduxjs/toolkit": "npm:^1.9.7"
     "@rsbuild/core": "npm:^2.0.3"
@@ -7150,6 +7185,7 @@ __metadata:
     lz-string: "npm:^1.4.4"
     mdast-util-from-markdown: "npm:^2.0.0"
     mdast-util-to-hast: "npm:^13.0.0"
+    monaco-editor: "npm:^0.55.1"
     normalize.css: "npm:^8.0.1"
     npm-run-all2: "npm:^8.0.0"
     phaser: "npm:~3.90.0"
@@ -9165,6 +9201,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"marked@npm:14.0.0":
+  version: 14.0.0
+  resolution: "marked@npm:14.0.0"
+  bin:
+    marked: bin/marked.js
+  checksum: 10c0/57a47cb110f7b1a10f398b0a7236f9183aad2dcd5345ee73f2732b6387e585d04cef472bc655d2f84c542296be9728e179aebe3ed7f2f8666b8a0a9dae592876
+  languageName: node
+  linkType: hard
+
 "math-intrinsics@npm:^1.1.0":
   version: 1.1.0
   resolution: "math-intrinsics@npm:1.1.0"
@@ -9982,6 +10027,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"monaco-editor@npm:^0.55.1":
+  version: 0.55.1
+  resolution: "monaco-editor@npm:0.55.1"
+  dependencies:
+    dompurify: "npm:3.2.7"
+    marked: "npm:14.0.0"
+  checksum: 10c0/c1a0cf887657b42c8996518bc5ee96bbd39c977f862d2a2b2018427c45f14b0dd25d1452278202056f6b1ead97981282ccacd7d7ad918d8f0ef084159f974a25
+  languageName: node
+  linkType: hard
+
 "mqtt-packet@npm:^6.8.0":
   version: 6.10.0
   resolution: "mqtt-packet@npm:6.10.0"
@@ -12624,6 +12679,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"state-local@npm:^1.0.6":
+  version: 1.0.7
+  resolution: "state-local@npm:1.0.7"
+  checksum: 10c0/8dc7daeac71844452fafb514a6d6b6f40d7e2b33df398309ea1c7b3948d6110c57f112b7196500a10c54fdde40291488c52c875575670fb5c819602deca48bd9
+  languageName: node
+  linkType: hard
+
 "std-env@npm:^4.0.0-rc.1":
   version: 4.0.0
   resolution: "std-env@npm:4.0.0"